dali-csharp-binder/src/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11
  12 #ifndef SWIGCSHARP
  13 #define SWIGCSHARP
  14 #endif
  15
  16 #define SWIG_DIRECTORS
  17
  18
  19 #ifdef __cplusplus
  20 /* SwigValueWrapper is described in swig.swg */
  21 template<typename T> class SwigValueWrapper {
  22   struct SwigMovePointer {
  23     T *ptr;
  24     SwigMovePointer(T *p) : ptr(p) { }
  25     ~SwigMovePointer() { delete ptr; }
  26     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  27   } pointer;
  28   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  29   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  30 public:
  31   SwigValueWrapper() : pointer(0) { }
  32   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  33   operator T&() const { return *pointer.ptr; }
  34   T *operator&() { return pointer.ptr; }
  35 };
  36
  37 template <typename T> T SwigValueInit() {
  38   return T();
  39 }
  40 #endif
  41
  42 /* -----------------------------------------------------------------------------
  43  *  This section contains generic SWIG labels for method/variable
  44  *  declarations/attributes, and other compiler dependent labels.
  45  * ----------------------------------------------------------------------------- */
  46
  47 /* template workaround for compilers that cannot correctly implement the C++ standard */
  48 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  49 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  50 #  define SWIGTEMPLATEDISAMBIGUATOR template
  51 # elif defined(__HP_aCC)
  52 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  53 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  54 #  define SWIGTEMPLATEDISAMBIGUATOR template
  55 # else
  56 #  define SWIGTEMPLATEDISAMBIGUATOR
  57 # endif
  58 #endif
  59
  60 /* inline attribute */
  61 #ifndef SWIGINLINE
  62 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  63 #   define SWIGINLINE inline
  64 # else
  65 #   define SWIGINLINE
  66 # endif
  67 #endif
  68
  69 /* attribute recognised by some compilers to avoid 'unused' warnings */
  70 #ifndef SWIGUNUSED
  71 # if defined(__GNUC__)
  72 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  73 #     define SWIGUNUSED __attribute__ ((__unused__))
  74 #   else
  75 #     define SWIGUNUSED
  76 #   endif
  77 # elif defined(__ICC)
  78 #   define SWIGUNUSED __attribute__ ((__unused__))
  79 # else
  80 #   define SWIGUNUSED
  81 # endif
  82 #endif
  83
  84 #ifndef SWIG_MSC_UNSUPPRESS_4505
  85 # if defined(_MSC_VER)
  86 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  87 # endif
  88 #endif
  89
  90 #ifndef SWIGUNUSEDPARM
  91 # ifdef __cplusplus
  92 #   define SWIGUNUSEDPARM(p)
  93 # else
  94 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  95 # endif
  96 #endif
  97
  98 /* internal SWIG method */
  99 #ifndef SWIGINTERN
 100 # define SWIGINTERN static SWIGUNUSED
 101 #endif
 102
 103 /* internal inline SWIG method */
 104 #ifndef SWIGINTERNINLINE
 105 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 106 #endif
 107
 108 /* exporting methods */
 109 #if defined(__GNUC__)
 110 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 111 #    ifndef GCC_HASCLASSVISIBILITY
 112 #      define GCC_HASCLASSVISIBILITY
 113 #    endif
 114 #  endif
 115 #endif
 116
 117 #ifndef SWIGEXPORT
 118 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 119 #   if defined(STATIC_LINKED)
 120 #     define SWIGEXPORT
 121 #   else
 122 #     define SWIGEXPORT __declspec(dllexport)
 123 #   endif
 124 # else
 125 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 126 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 127 #   else
 128 #     define SWIGEXPORT
 129 #   endif
 130 # endif
 131 #endif
 132
 133 /* calling conventions for Windows */
 134 #ifndef SWIGSTDCALL
 135 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 136 #   define SWIGSTDCALL __stdcall
 137 # else
 138 #   define SWIGSTDCALL
 139 # endif
 140 #endif
 141
 142 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 143 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 144 # define _CRT_SECURE_NO_DEPRECATE
 145 #endif
 146
 147 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 148 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 149 # define _SCL_SECURE_NO_DEPRECATE
 150 #endif
 151
 152 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 153 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 154 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 155 #endif
 156
 157 /* Intel's compiler complains if a variable which was never initialised is
 158  * cast to void, which is a common idiom which we use to indicate that we
 159  * are aware a variable isn't used.  So we just silence that warning.
 160  * See: https://github.com/swig/swig/issues/192 for more discussion.
 161  */
 162 #ifdef __INTEL_COMPILER
 163 # pragma warning disable 592
 164 #endif
 165
 166
 167 #include <stdlib.h>
 168 #include <string.h>
 169 #include <stdio.h>
 170
 171
 172 /* Support for throwing C# exceptions from C/C++. There are two types:
 173  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 174 typedef enum {
 175   SWIG_CSharpApplicationException,
 176   SWIG_CSharpArithmeticException,
 177   SWIG_CSharpDivideByZeroException,
 178   SWIG_CSharpIndexOutOfRangeException,
 179   SWIG_CSharpInvalidCastException,
 180   SWIG_CSharpInvalidOperationException,
 181   SWIG_CSharpIOException,
 182   SWIG_CSharpNullReferenceException,
 183   SWIG_CSharpOutOfMemoryException,
 184   SWIG_CSharpOverflowException,
 185   SWIG_CSharpSystemException
 186 } SWIG_CSharpExceptionCodes;
 187
 188 typedef enum {
 189   SWIG_CSharpArgumentException,
 190   SWIG_CSharpArgumentNullException,
 191   SWIG_CSharpArgumentOutOfRangeException
 192 } SWIG_CSharpExceptionArgumentCodes;
 193
 194 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 195 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 196
 197 typedef struct {
 198   SWIG_CSharpExceptionCodes code;
 199   SWIG_CSharpExceptionCallback_t callback;
 200 } SWIG_CSharpException_t;
 201
 202 typedef struct {
 203   SWIG_CSharpExceptionArgumentCodes code;
 204   SWIG_CSharpExceptionArgumentCallback_t callback;
 205 } SWIG_CSharpExceptionArgument_t;
 206
 207 static SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 208   { SWIG_CSharpApplicationException, NULL },
 209   { SWIG_CSharpArithmeticException, NULL },
 210   { SWIG_CSharpDivideByZeroException, NULL },
 211   { SWIG_CSharpIndexOutOfRangeException, NULL },
 212   { SWIG_CSharpInvalidCastException, NULL },
 213   { SWIG_CSharpInvalidOperationException, NULL },
 214   { SWIG_CSharpIOException, NULL },
 215   { SWIG_CSharpNullReferenceException, NULL },
 216   { SWIG_CSharpOutOfMemoryException, NULL },
 217   { SWIG_CSharpOverflowException, NULL },
 218   { SWIG_CSharpSystemException, NULL }
 219 };
 220
 221 static SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 222   { SWIG_CSharpArgumentException, NULL },
 223   { SWIG_CSharpArgumentNullException, NULL },
 224   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 225 };
 226
 227 static void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 228   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 229   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 230     callback = SWIG_csharp_exceptions[code].callback;
 231   }
 232   callback(msg);
 233 }
 234
 235 static void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 236   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 237   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 238     callback = SWIG_csharp_exceptions_argument[code].callback;
 239   }
 240   callback(msg, param_name);
 241 }
 242
 243
 244 #ifdef __cplusplus
 245 extern "C"
 246 #endif
 247 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 248                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 249                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 250                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 251                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 252                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 253                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 254                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 255                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 256                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 257                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 258                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 259   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 267   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 268   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 269   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 270 }
 271
 272 #ifdef __cplusplus
 273 extern "C"
 274 #endif
 275 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 276                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 277                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 278                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 279   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 280   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 281   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 282 }
 283
 284
 285 /* Callback for returning strings to C# without leaking memory */
 286 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 287 static SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 288
 289
 290 #ifdef __cplusplus
 291 extern "C"
 292 #endif
 293 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 294   SWIG_csharp_string_callback = callback;
 295 }
 296
 297
 298 /* Contract support */
 299
 300 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 301
 302 /*  Errors in SWIG */
 303 #define  SWIG_UnknownError         -1
 304 #define  SWIG_IOError              -2
 305 #define  SWIG_RuntimeError         -3
 306 #define  SWIG_IndexError           -4
 307 #define  SWIG_TypeError            -5
 308 #define  SWIG_DivisionByZero       -6
 309 #define  SWIG_OverflowError        -7
 310 #define  SWIG_SyntaxError          -8
 311 #define  SWIG_ValueError           -9
 312 #define  SWIG_SystemError          -10
 313 #define  SWIG_AttributeError       -11
 314 #define  SWIG_MemoryError          -12
 315 #define  SWIG_NullReferenceError   -13
 316
 317
 318
 319 /* -----------------------------------------------------------------------------
 320  * director_common.swg
 321  *
 322  * This file contains support for director classes which is common between
 323  * languages.
 324  * ----------------------------------------------------------------------------- */
 325
 326 /*
 327   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 328   'Swig' namespace. This could be useful for multi-modules projects.
 329 */
 330 #ifdef SWIG_DIRECTOR_STATIC
 331 /* Force anonymous (static) namespace */
 332 #define Swig
 333 #endif
 334 /* -----------------------------------------------------------------------------
 335  * director.swg
 336  *
 337  * This file contains support for director classes so that C# proxy
 338  * methods can be called from C++.
 339  * ----------------------------------------------------------------------------- */
 340
 341 #if defined(DEBUG_DIRECTOR_OWNED)
 342 #include <iostream>
 343 #endif
 344 #include <string>
 345 #include <exception>
 346
 347 namespace Swig {
 348   /* Director base class - not currently used in C# directors */
 349   class Director {
 350   };
 351
 352   /* Base class for director exceptions */
 353   class DirectorException : public std::exception {
 354   protected:
 355     std::string swig_msg;
 356
 357   public:
 358     DirectorException(const char *msg) : swig_msg(msg) {
 359     }
 360
 361     DirectorException(const std::string &msg) : swig_msg(msg) {
 362     }
 363
 364     virtual ~DirectorException() throw() {
 365     }
 366
 367     const char *what() const throw() {
 368       return swig_msg.c_str();
 369     }
 370   };
 371
 372   /* Pure virtual method exception */
 373   class DirectorPureVirtualException : public DirectorException {
 374   public:
 375     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 376     }
 377   };
 378 }
 379
 380
 381 SWIGINTERN void SWIG_CSharpException(int code, const char *msg) {
 382   if (code == SWIG_ValueError) {
 383     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 384     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 385   } else {
 386     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 387     switch(code) {
 388     case SWIG_MemoryError:
 389       exception_code = SWIG_CSharpOutOfMemoryException;
 390       break;
 391     case SWIG_IndexError:
 392       exception_code = SWIG_CSharpIndexOutOfRangeException;
 393       break;
 394     case SWIG_DivisionByZero:
 395       exception_code = SWIG_CSharpDivideByZeroException;
 396       break;
 397     case SWIG_IOError:
 398       exception_code = SWIG_CSharpIOException;
 399       break;
 400     case SWIG_OverflowError:
 401       exception_code = SWIG_CSharpOverflowException;
 402       break;
 403     case SWIG_RuntimeError:
 404     case SWIG_TypeError:
 405     case SWIG_SyntaxError:
 406     case SWIG_SystemError:
 407     case SWIG_UnknownError:
 408     default:
 409       exception_code = SWIG_CSharpApplicationException;
 410       break;
 411     }
 412     SWIG_CSharpSetPendingException(exception_code, msg);
 413   }
 414 }
 415
 416
 417 #include <stdexcept>
 418
 419
 420 #define SWIGSTDCALL
 421
 422
 423 #include <dali/dali.h>
 424 #include <dali-toolkit/dali-toolkit.h>
 425 #include <dali/devel-api/events/key-event-devel.h>
 426
 427 #include <dali/devel-api/actors/actor-devel.h>
 428
 429 #include <dali/public-api/math/matrix.h>
 430 #include <dali/public-api/math/matrix3.h>
 431 #include <dali/public-api/math/viewport.h>
 432 #include <dali/public-api/object/property-key.h>
 433 #include <dali/devel-api/object/csharp-type-info.h>
 434 #include <dali/devel-api/object/csharp-type-registry.h>
 435
 436 #include <dali/public-api/adaptor-framework/timer.h>
 437 #include <dali/public-api/adaptor-framework/window.h>
 438 #include <dali/public-api/adaptor-framework/style-change.h>
 439 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
 440 #include <dali/devel-api/adaptor-framework/application-extensions.h>
 441 #include <dali/devel-api/adaptor-framework/window-devel.h>
 442
 443 #include <dali/devel-api/images/nine-patch-image.h>
 444
 445 #include <dali-toolkit/devel-api/builder/builder.h>
 446
 447 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 448 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 449
 450 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 451 #include <dali-toolkit/devel-api/controls/progress-bar/progress-bar.h>
 452 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 455 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 456 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 457 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 458
 459 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 460 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 461 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 462
 463 #include <dali-toolkit/devel-api/visuals/text-visual-properties.h>
 464
 465 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 466
 467 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 468
 469 // add here SWIG version check
 470
 471 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 472 // disable Swig-dependent warnings
 473
 474 // 'identifier1' has C-linkage specified,
 475 // but returns UDT 'identifier2' which is incompatible with C
 476 #pragma warning(disable: 4190)
 477
 478 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 479 #pragma warning(disable: 4800)
 480
 481 // debug info too long etc etc
 482 #pragma warning(disable: 4786)
 483 #endif
 484
 485
 486 #include <stdexcept>
 487
 488
 489 #include <string>
 490
 491
 492 #include <vector>
 493 #include <algorithm>
 494 #include <stdexcept>
 495
 496
 497 #include <map>
 498 #include <algorithm>
 499 #include <stdexcept>
 500
 501
 502 #include <utility>
 503
 504
 505 typedef float floatp;
 506
 507 SWIGINTERN floatp *new_floatp(){
 508   return new float();
 509 }
 510 SWIGINTERN void delete_floatp(floatp *self){
 511   if (self) delete self;
 512 }
 513 SWIGINTERN void floatp_assign(floatp *self,float value){
 514   *self = value;
 515 }
 516 SWIGINTERN float floatp_value(floatp *self){
 517   return *self;
 518 }
 519 SWIGINTERN float *floatp_cast(floatp *self){
 520   return self;
 521 }
 522 SWIGINTERN floatp *floatp_frompointer(float *t){
 523   return (floatp *) t;
 524 }
 525
 526 typedef int intp;
 527
 528 SWIGINTERN intp *new_intp(){
 529   return new int();
 530 }
 531 SWIGINTERN void delete_intp(intp *self){
 532   if (self) delete self;
 533 }
 534 SWIGINTERN void intp_assign(intp *self,int value){
 535   *self = value;
 536 }
 537 SWIGINTERN int intp_value(intp *self){
 538   return *self;
 539 }
 540 SWIGINTERN int *intp_cast(intp *self){
 541   return self;
 542 }
 543 SWIGINTERN intp *intp_frompointer(int *t){
 544   return (intp *) t;
 545 }
 546
 547 typedef double doublep;
 548
 549 SWIGINTERN doublep *new_doublep(){
 550   return new double();
 551 }
 552 SWIGINTERN void delete_doublep(doublep *self){
 553   if (self) delete self;
 554 }
 555 SWIGINTERN void doublep_assign(doublep *self,double value){
 556   *self = value;
 557 }
 558 SWIGINTERN double doublep_value(doublep *self){
 559   return *self;
 560 }
 561 SWIGINTERN double *doublep_cast(doublep *self){
 562   return self;
 563 }
 564 SWIGINTERN doublep *doublep_frompointer(double *t){
 565   return (doublep *) t;
 566 }
 567
 568 typedef unsigned int uintp;
 569
 570 SWIGINTERN uintp *new_uintp(){
 571   return new unsigned int();
 572 }
 573 SWIGINTERN void delete_uintp(uintp *self){
 574   if (self) delete self;
 575 }
 576 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 577   *self = value;
 578 }
 579 SWIGINTERN unsigned int uintp_value(uintp *self){
 580   return *self;
 581 }
 582 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 583   return self;
 584 }
 585 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 586   return (uintp *) t;
 587 }
 588
 589 typedef unsigned short ushortp;
 590
 591 SWIGINTERN ushortp *new_ushortp(){
 592   return new unsigned short();
 593 }
 594 SWIGINTERN void delete_ushortp(ushortp *self){
 595   if (self) delete self;
 596 }
 597 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 598   *self = value;
 599 }
 600 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 601   return *self;
 602 }
 603 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 604   return self;
 605 }
 606 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 607   return (ushortp *) t;
 608 }
 609
 610 unsigned int int_to_uint(int x) {
 611    return (unsigned int) x;
 612 }
 613
 614
 615 using namespace Dali;
 616 using namespace Dali::Toolkit;
 617
 618 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self){
 619
 620      // C++ code. DALi uses Handle <-> Body design pattern.
 621      // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 622      // Handles in DALi can be converted into a boolean type
 623      // to check if the handle has a valid body attached to it.
 624      // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 625      if( *self )
 626      {
 627        return true;
 628      }
 629      else
 630      {
 631        return false;
 632      }
 633     }
 634 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs){
 635
 636      // C++ code. Check if two handles reference the same implemtion
 637      if( *self == rhs)
 638      {
 639        return true;
 640      }
 641      else
 642      {
 643        return false;
 644      }
 645     }
 646 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 647      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 648    }
 649 SWIGINTERN void Dali_TypeRegistration_RegisterProperty(std::string const &controlName,std::string const &propertyName,int index,Dali::Property::Type type,Dali::CSharpTypeInfo::SetPropertyFunction setFunc,Dali::CSharpTypeInfo::GetPropertyFunction getFunc){
 650      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 651    }
 652 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 653         std::vector< Dali::TouchPoint >* pv = 0;
 654         if (capacity >= 0) {
 655           pv = new std::vector< Dali::TouchPoint >();
 656           pv->reserve(capacity);
 657        } else {
 658           throw std::out_of_range("capacity");
 659        }
 660        return pv;
 661       }
 662 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 663         if (index>=0 && index<(int)self->size())
 664           return (*self)[index];
 665         else
 666           throw std::out_of_range("index");
 667       }
 668 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 669         if (index>=0 && index<(int)self->size())
 670           return (*self)[index];
 671         else
 672           throw std::out_of_range("index");
 673       }
 674 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 675         if (index>=0 && index<(int)self->size())
 676           (*self)[index] = val;
 677         else
 678           throw std::out_of_range("index");
 679       }
 680 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 681         self->insert(self->end(), values.begin(), values.end());
 682       }
 683 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 684         if (index < 0)
 685           throw std::out_of_range("index");
 686         if (count < 0)
 687           throw std::out_of_range("count");
 688         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 689           throw std::invalid_argument("invalid range");
 690         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 691       }
 692 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 693         if (index>=0 && index<(int)self->size()+1)
 694           self->insert(self->begin()+index, x);
 695         else
 696           throw std::out_of_range("index");
 697       }
 698 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 699         if (index>=0 && index<(int)self->size()+1)
 700           self->insert(self->begin()+index, values.begin(), values.end());
 701         else
 702           throw std::out_of_range("index");
 703       }
 704 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 705         if (index>=0 && index<(int)self->size())
 706           self->erase(self->begin() + index);
 707         else
 708           throw std::out_of_range("index");
 709       }
 710 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 711         if (index < 0)
 712           throw std::out_of_range("index");
 713         if (count < 0)
 714           throw std::out_of_range("count");
 715         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 716           throw std::invalid_argument("invalid range");
 717         self->erase(self->begin()+index, self->begin()+index+count);
 718       }
 719 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 720         if (count < 0)
 721           throw std::out_of_range("count");
 722         return new std::vector< Dali::TouchPoint >(count, value);
 723       }
 724 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 725         std::reverse(self->begin(), self->end());
 726       }
 727 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 728         if (index < 0)
 729           throw std::out_of_range("index");
 730         if (count < 0)
 731           throw std::out_of_range("count");
 732         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 733           throw std::invalid_argument("invalid range");
 734         std::reverse(self->begin()+index, self->begin()+index+count);
 735       }
 736 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 737         if (index < 0)
 738           throw std::out_of_range("index");
 739         if (index+values.size() > self->size())
 740           throw std::out_of_range("index");
 741         std::copy(values.begin(), values.end(), self->begin()+index);
 742       }
 743 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 744          return self->Empty();
 745       }
 746 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 747         return self->GetConnectionCount();
 748       }
 749 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 750           self->Connect( func );
 751       }
 752 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 753           self->Disconnect( func );
 754       }
 755 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 756           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 757 /*@SWIG@*/ self->Emit( arg );
 758       }
 759 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 760          return self->Empty();
 761       }
 762 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 763         return self->GetConnectionCount();
 764       }
 765 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 766           self->Connect( func );
 767       }
 768 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 769           self->Disconnect( func );
 770       }
 771 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 772           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 773 /*@SWIG@*/ self->Emit( arg );
 774       }
 775 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 776          return self->Empty();
 777       }
 778 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::RefObject const *) > const *self){
 779         return self->GetConnectionCount();
 780       }
 781 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 782           self->Connect( func );
 783       }
 784 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 785           self->Disconnect( func );
 786       }
 787 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::RefObject const *) > *self,Dali::RefObject const *arg){
 788           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 789 /*@SWIG@*/ self->Emit( arg );
 790       }
 791 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 792          return self->Empty();
 793       }
 794 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 795         return self->GetConnectionCount();
 796       }
 797 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 798           self->Connect( func );
 799       }
 800 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 801           self->Disconnect( func );
 802       }
 803 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 804           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 805 /*@SWIG@*/ self->Emit( arg );
 806       }
 807 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 808          return self->Empty();
 809       }
 810 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 811         return self->GetConnectionCount();
 812       }
 813 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 814           self->Connect( func );
 815       }
 816 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 817           self->Disconnect( func );
 818       }
 819 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 820           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 821 /*@SWIG@*/ self->Emit( arg );
 822       }
 823 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 824          return self->Empty();
 825       }
 826 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 827         return self->GetConnectionCount();
 828       }
 829 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 830         self->Connect( func );
 831       }
 832 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 833         self->Disconnect( func );
 834       }
 835 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,Dali::Actor arg1,Dali::LongPressGesture const &arg2){
 836         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 837 /*@SWIG@*/ self->Emit( arg1, arg2 );
 838       }
 839 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 840          return self->Empty();
 841       }
 842 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 843         return self->GetConnectionCount();
 844       }
 845 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 846         self->Connect( func );
 847       }
 848 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 849         self->Disconnect( func );
 850       }
 851 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,Dali::Actor arg1,Dali::TouchData const &arg2){
 852         return self->Emit( arg1, arg2 );
 853       }
 854 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 855          return self->Empty();
 856       }
 857 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 858         return self->GetConnectionCount();
 859       }
 860 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 861         self->Connect( func );
 862       }
 863 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 864         self->Disconnect( func );
 865       }
 866 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,Dali::Actor arg1,Dali::HoverEvent const &arg2){
 867         return self->Emit( arg1, arg2 );
 868       }
 869 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 870          return self->Empty();
 871       }
 872 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 873         return self->GetConnectionCount();
 874       }
 875 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 876         self->Connect( func );
 877       }
 878 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 879         self->Disconnect( func );
 880       }
 881 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,Dali::Actor arg1,Dali::WheelEvent const &arg2){
 882         return self->Emit( arg1, arg2 );
 883       }
 884 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 885          return self->Empty();
 886       }
 887 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 888         return self->GetConnectionCount();
 889       }
 890 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 891           self->Connect( func );
 892       }
 893 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 894           self->Disconnect( func );
 895       }
 896 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 897           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 898 /*@SWIG@*/ self->Emit( arg );
 899       }
 900 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 901          return self->Empty();
 902       }
 903 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 904         return self->GetConnectionCount();
 905       }
 906 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 907           self->Connect( func );
 908       }
 909 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 910           self->Disconnect( func );
 911       }
 912 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::KeyEvent const &) > *self,Dali::KeyEvent const &arg){
 913           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 914 /*@SWIG@*/ self->Emit( arg );
 915       }
 916 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 917          return self->Empty();
 918       }
 919 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::TouchData const &) > const *self){
 920         return self->GetConnectionCount();
 921       }
 922 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 923           self->Connect( func );
 924       }
 925 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 926           self->Disconnect( func );
 927       }
 928 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::TouchData const &) > *self,Dali::TouchData const &arg){
 929           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 930 /*@SWIG@*/ self->Emit( arg );
 931       }
 932 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 933          return self->Empty();
 934       }
 935 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 936         return self->GetConnectionCount();
 937       }
 938 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
 939           self->Connect( func );
 940       }
 941 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
 942           self->Disconnect( func );
 943       }
 944 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::WheelEvent const &) > *self,Dali::WheelEvent const &arg){
 945           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 946 /*@SWIG@*/ self->Emit( arg );
 947       }
 948 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
 949          return self->Empty();
 950       }
 951 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
 952         return self->GetConnectionCount();
 953       }
 954 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
 955         self->Connect( func );
 956       }
 957 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
 958         self->Disconnect( func );
 959       }
 960 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,Dali::Actor arg1,Dali::PanGesture const &arg2){
 961         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 962 /*@SWIG@*/ self->Emit( arg1, arg2 );
 963       }
 964 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
 965          return self->Empty();
 966       }
 967 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
 968         return self->GetConnectionCount();
 969       }
 970 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
 971         self->Connect( func );
 972       }
 973 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
 974         self->Disconnect( func );
 975       }
 976 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,Dali::Actor arg1,Dali::PinchGesture const &arg2){
 977         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 978 /*@SWIG@*/ self->Emit( arg1, arg2 );
 979       }
 980 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
 981          return self->Empty();
 982       }
 983 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
 984         return self->GetConnectionCount();
 985       }
 986 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
 987         self->Connect( func );
 988       }
 989 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
 990         self->Disconnect( func );
 991       }
 992 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,Dali::Actor arg1,Dali::TapGesture const &arg2){
 993         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 994 /*@SWIG@*/ self->Emit( arg1, arg2 );
 995       }
 996 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Animation &) > const *self){
 997          return self->Empty();
 998       }
 999 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Animation &) > const *self){
1000         return self->GetConnectionCount();
1001       }
1002 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
1003           self->Connect( func );
1004       }
1005 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
1006           self->Disconnect( func );
1007       }
1008 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Animation &) > *self,Dali::Animation &arg){
1009           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1010 /*@SWIG@*/ self->Emit( arg );
1011       }
1012 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1013          return self->Empty();
1014       }
1015 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1016         return self->GetConnectionCount();
1017       }
1018 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1019           self->Connect( func );
1020       }
1021 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1022           self->Disconnect( func );
1023       }
1024 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1025           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1026 /*@SWIG@*/ self->Emit( arg );
1027       }
1028
1029   // keep argcs and argv so they're always available to DALi
1030   int argC = 1;
1031   char **argV = NULL;
1032
1033 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Application &) > const *self){
1034          return self->Empty();
1035       }
1036 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &) > const *self){
1037         return self->GetConnectionCount();
1038       }
1039 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
1040           self->Connect( func );
1041       }
1042 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
1043           self->Disconnect( func );
1044       }
1045 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Application &) > *self,Dali::Application &arg){
1046           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1047 /*@SWIG@*/ self->Emit( arg );
1048       }
1049 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::Application &,void *) > const *self){
1050          return self->Empty();
1051       }
1052 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &,void *) > const *self){
1053         return self->GetConnectionCount();
1054       }
1055 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::Application &,void *) > *self,void (*func)(Dali::Application &,void *)){
1056         self->Connect( func );
1057       }
1058 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &,void *) > *self,void (*func)(Dali::Application &,void *)){
1059         self->Disconnect( func );
1060       }
1061 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::Application &,void *) > *self,Dali::Application &arg1,void *arg2){
1062         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1063 /*@SWIG@*/ self->Emit( arg1, arg2 );
1064       }
1065 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1066          return self->Empty();
1067       }
1068 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1069         return self->GetConnectionCount();
1070       }
1071 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1072           self->Connect( func );
1073       }
1074 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1075           self->Disconnect( func );
1076       }
1077 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1078           return self->Emit();
1079       }
1080 SWIGINTERN bool Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty(Dali::Signal< void (bool) > const *self){
1081          return self->Empty();
1082       }
1083 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (bool) > const *self){
1084         return self->GetConnectionCount();
1085       }
1086 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(Dali::Signal< void (bool) > *self,void (*func)(bool)){
1087           self->Connect( func );
1088       }
1089 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(Dali::Signal< void (bool) > *self,void (*func)(bool)){
1090           self->Disconnect( func );
1091       }
1092 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(Dali::Signal< void (bool) > *self,bool arg){
1093           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1094 /*@SWIG@*/ self->Emit( arg );
1095       }
1096 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1097         std::vector< unsigned int >* pv = 0;
1098         if (capacity >= 0) {
1099           pv = new std::vector< unsigned int >();
1100           pv->reserve(capacity);
1101        } else {
1102           throw std::out_of_range("capacity");
1103        }
1104        return pv;
1105       }
1106 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1107         if (index>=0 && index<(int)self->size())
1108           return (*self)[index];
1109         else
1110           throw std::out_of_range("index");
1111       }
1112 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1113         if (index>=0 && index<(int)self->size())
1114           return (*self)[index];
1115         else
1116           throw std::out_of_range("index");
1117       }
1118 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1119         if (index>=0 && index<(int)self->size())
1120           (*self)[index] = val;
1121         else
1122           throw std::out_of_range("index");
1123       }
1124 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1125         self->insert(self->end(), values.begin(), values.end());
1126       }
1127 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1128         if (index < 0)
1129           throw std::out_of_range("index");
1130         if (count < 0)
1131           throw std::out_of_range("count");
1132         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1133           throw std::invalid_argument("invalid range");
1134         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1135       }
1136 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1137         if (index>=0 && index<(int)self->size()+1)
1138           self->insert(self->begin()+index, x);
1139         else
1140           throw std::out_of_range("index");
1141       }
1142 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1143         if (index>=0 && index<(int)self->size()+1)
1144           self->insert(self->begin()+index, values.begin(), values.end());
1145         else
1146           throw std::out_of_range("index");
1147       }
1148 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1149         if (index>=0 && index<(int)self->size())
1150           self->erase(self->begin() + index);
1151         else
1152           throw std::out_of_range("index");
1153       }
1154 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1155         if (index < 0)
1156           throw std::out_of_range("index");
1157         if (count < 0)
1158           throw std::out_of_range("count");
1159         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1160           throw std::invalid_argument("invalid range");
1161         self->erase(self->begin()+index, self->begin()+index+count);
1162       }
1163 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1164         if (count < 0)
1165           throw std::out_of_range("count");
1166         return new std::vector< unsigned int >(count, value);
1167       }
1168 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1169         std::reverse(self->begin(), self->end());
1170       }
1171 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1172         if (index < 0)
1173           throw std::out_of_range("index");
1174         if (count < 0)
1175           throw std::out_of_range("count");
1176         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1177           throw std::invalid_argument("invalid range");
1178         std::reverse(self->begin()+index, self->begin()+index+count);
1179       }
1180 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1181         if (index < 0)
1182           throw std::out_of_range("index");
1183         if (index+values.size() > self->size())
1184           throw std::out_of_range("index");
1185         std::copy(values.begin(), values.end(), self->begin()+index);
1186       }
1187 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1188         return std::find(self->begin(), self->end(), value) != self->end();
1189       }
1190 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1191         int index = -1;
1192         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1193         if (it != self->end())
1194           index = (int)(it - self->begin());
1195         return index;
1196       }
1197 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1198         int index = -1;
1199         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1200         if (rit != self->rend())
1201           index = (int)(self->rend() - 1 - rit);
1202         return index;
1203       }
1204 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1205         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1206         if (it != self->end()) {
1207           self->erase(it);
1208           return true;
1209         }
1210         return false;
1211       }
1212 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *new_std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg___SWIG_2(int capacity){
1213         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1214         if (capacity >= 0) {
1215           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1216           pv->reserve(capacity);
1217        } else {
1218           throw std::out_of_range("capacity");
1219        }
1220        return pv;
1221       }
1222 SWIGINTERN std::pair< unsigned int,Dali::Actor > std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1223         if (index>=0 && index<(int)self->size())
1224           return (*self)[index];
1225         else
1226           throw std::out_of_range("index");
1227       }
1228 SWIGINTERN std::pair< unsigned int,Dali::Actor > const &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1229         if (index>=0 && index<(int)self->size())
1230           return (*self)[index];
1231         else
1232           throw std::out_of_range("index");
1233       }
1234 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__setitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &val){
1235         if (index>=0 && index<(int)self->size())
1236           (*self)[index] = val;
1237         else
1238           throw std::out_of_range("index");
1239       }
1240 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__AddRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1241         self->insert(self->end(), values.begin(), values.end());
1242       }
1243 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__GetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1244         if (index < 0)
1245           throw std::out_of_range("index");
1246         if (count < 0)
1247           throw std::out_of_range("count");
1248         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1249           throw std::invalid_argument("invalid range");
1250         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1251       }
1252 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Insert(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &x){
1253         if (index>=0 && index<(int)self->size()+1)
1254           self->insert(self->begin()+index, x);
1255         else
1256           throw std::out_of_range("index");
1257       }
1258 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__InsertRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1259         if (index>=0 && index<(int)self->size()+1)
1260           self->insert(self->begin()+index, values.begin(), values.end());
1261         else
1262           throw std::out_of_range("index");
1263       }
1264 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1265         if (index>=0 && index<(int)self->size())
1266           self->erase(self->begin() + index);
1267         else
1268           throw std::out_of_range("index");
1269       }
1270 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1271         if (index < 0)
1272           throw std::out_of_range("index");
1273         if (count < 0)
1274           throw std::out_of_range("count");
1275         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1276           throw std::invalid_argument("invalid range");
1277         self->erase(self->begin()+index, self->begin()+index+count);
1278       }
1279 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Repeat(std::pair< unsigned int,Dali::Actor > const &value,int count){
1280         if (count < 0)
1281           throw std::out_of_range("count");
1282         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1283       }
1284 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(std::vector< std::pair< unsigned int,Dali::Actor > > *self){
1285         std::reverse(self->begin(), self->end());
1286       }
1287 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1288         if (index < 0)
1289           throw std::out_of_range("index");
1290         if (count < 0)
1291           throw std::out_of_range("count");
1292         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1293           throw std::invalid_argument("invalid range");
1294         std::reverse(self->begin()+index, self->begin()+index+count);
1295       }
1296 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__SetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1297         if (index < 0)
1298           throw std::out_of_range("index");
1299         if (index+values.size() > self->size())
1300           throw std::out_of_range("index");
1301         std::copy(values.begin(), values.end(), self->begin()+index);
1302       }
1303 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1304         std::vector< Dali::Actor >* pv = 0;
1305         if (capacity >= 0) {
1306           pv = new std::vector< Dali::Actor >();
1307           pv->reserve(capacity);
1308        } else {
1309           throw std::out_of_range("capacity");
1310        }
1311        return pv;
1312       }
1313 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1314         if (index>=0 && index<(int)self->size())
1315           return (*self)[index];
1316         else
1317           throw std::out_of_range("index");
1318       }
1319 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1320         if (index>=0 && index<(int)self->size())
1321           return (*self)[index];
1322         else
1323           throw std::out_of_range("index");
1324       }
1325 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1326         if (index>=0 && index<(int)self->size())
1327           (*self)[index] = val;
1328         else
1329           throw std::out_of_range("index");
1330       }
1331 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1332         self->insert(self->end(), values.begin(), values.end());
1333       }
1334 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1335         if (index < 0)
1336           throw std::out_of_range("index");
1337         if (count < 0)
1338           throw std::out_of_range("count");
1339         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1340           throw std::invalid_argument("invalid range");
1341         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1342       }
1343 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1344         if (index>=0 && index<(int)self->size()+1)
1345           self->insert(self->begin()+index, x);
1346         else
1347           throw std::out_of_range("index");
1348       }
1349 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1350         if (index>=0 && index<(int)self->size()+1)
1351           self->insert(self->begin()+index, values.begin(), values.end());
1352         else
1353           throw std::out_of_range("index");
1354       }
1355 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1356         if (index>=0 && index<(int)self->size())
1357           self->erase(self->begin() + index);
1358         else
1359           throw std::out_of_range("index");
1360       }
1361 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1362         if (index < 0)
1363           throw std::out_of_range("index");
1364         if (count < 0)
1365           throw std::out_of_range("count");
1366         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1367           throw std::invalid_argument("invalid range");
1368         self->erase(self->begin()+index, self->begin()+index+count);
1369       }
1370 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1371         if (count < 0)
1372           throw std::out_of_range("count");
1373         return new std::vector< Dali::Actor >(count, value);
1374       }
1375 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1376         std::reverse(self->begin(), self->end());
1377       }
1378 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1379         if (index < 0)
1380           throw std::out_of_range("index");
1381         if (count < 0)
1382           throw std::out_of_range("count");
1383         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1384           throw std::invalid_argument("invalid range");
1385         std::reverse(self->begin()+index, self->begin()+index+count);
1386       }
1387 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1388         if (index < 0)
1389           throw std::out_of_range("index");
1390         if (index+values.size() > self->size())
1391           throw std::out_of_range("index");
1392         std::copy(values.begin(), values.end(), self->begin()+index);
1393       }
1394 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1395          return self->Empty();
1396       }
1397 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1398         return self->GetConnectionCount();
1399       }
1400 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1401           self->Connect( func );
1402       }
1403 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1404           self->Disconnect( func );
1405       }
1406 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,Dali::Toolkit::AccessibilityManager &arg){
1407           return self->Emit( arg );
1408       }
1409 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1410          return self->Empty();
1411       }
1412 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1413         return self->GetConnectionCount();
1414       }
1415 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1416         self->Connect( func );
1417       }
1418 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1419         self->Disconnect( func );
1420       }
1421 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,Dali::Actor arg1,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg2){
1422         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1423 /*@SWIG@*/ self->Emit( arg1, arg2 );
1424       }
1425 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1426          return self->Empty();
1427       }
1428 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1429         return self->GetConnectionCount();
1430       }
1431 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1432         self->Connect( func );
1433       }
1434 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1435         self->Disconnect( func );
1436       }
1437 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,Dali::Actor arg1,Dali::Actor arg2){
1438         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1439 /*@SWIG@*/ self->Emit( arg1, arg2 );
1440       }
1441 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1442          return self->Empty();
1443       }
1444 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1445         return self->GetConnectionCount();
1446       }
1447 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1448         self->Connect( func );
1449       }
1450 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1451         self->Disconnect( func );
1452       }
1453 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool) > *self,Dali::Actor arg1,bool arg2){
1454         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1455 /*@SWIG@*/ self->Emit( arg1, arg2 );
1456       }
1457 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1458          return self->Empty();
1459       }
1460 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1461         return self->GetConnectionCount();
1462       }
1463 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1464         self->Connect( func );
1465       }
1466 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1467         self->Disconnect( func );
1468       }
1469 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,Dali::Toolkit::StyleManager arg1,Dali::StyleChange::Type arg2){
1470         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1471 /*@SWIG@*/ self->Emit( arg1, arg2 );
1472       }
1473 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1474          return self->Empty();
1475       }
1476 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1477         return self->GetConnectionCount();
1478       }
1479 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1480           self->Connect( func );
1481       }
1482 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1483           self->Disconnect( func );
1484       }
1485 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1486           return self->Emit( arg );
1487       }
1488 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1489          return self->Empty();
1490       }
1491 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1492         return self->GetConnectionCount();
1493       }
1494 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1495           self->Connect( func );
1496       }
1497 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1498           self->Disconnect( func );
1499       }
1500 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1501           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1502 /*@SWIG@*/ self->Emit( arg );
1503       }
1504 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1505          return self->Empty();
1506       }
1507 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1508         return self->GetConnectionCount();
1509       }
1510 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1511           return self->Connect( func );
1512       }
1513 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1514           self->Disconnect( func );
1515       }
1516 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,Dali::Toolkit::PageTurnView arg1,unsigned int arg2,bool arg3){
1517           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1518 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1519       }
1520 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1521          return self->Empty();
1522       }
1523 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1524         return self->GetConnectionCount();
1525       }
1526 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1527           self->Connect( func );
1528       }
1529 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1530           self->Disconnect( func );
1531       }
1532 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1533           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1534 /*@SWIG@*/ self->Emit( arg );
1535       }
1536 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1537          return self->Empty();
1538       }
1539 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1540         return self->GetConnectionCount();
1541       }
1542 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1543           return self->Connect( func );
1544       }
1545 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1546           self->Disconnect( func );
1547       }
1548 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,Dali::Toolkit::ProgressBar arg1,float arg2,float arg3){
1549           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1550 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1551       }
1552 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1553          return self->Empty();
1554       }
1555 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1556         return self->GetConnectionCount();
1557       }
1558 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1559           self->Connect( func );
1560       }
1561 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1562           self->Disconnect( func );
1563       }
1564 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,Dali::Toolkit::ScrollView::SnapEvent const &arg){
1565           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1566 /*@SWIG@*/ self->Emit( arg );
1567       }
1568 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1569          return self->Empty();
1570       }
1571 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1572         return self->GetConnectionCount();
1573       }
1574 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1575           self->Connect( func );
1576       }
1577 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1578           self->Disconnect( func );
1579       }
1580 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Vector2 const &) > *self,Dali::Vector2 const &arg){
1581           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1582 /*@SWIG@*/ self->Emit( arg );
1583       }
1584 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1585          return self->Empty();
1586       }
1587 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1588         return self->GetConnectionCount();
1589       }
1590 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,void (*func)(Dali::Toolkit::TextEditor)){
1591           self->Connect( func );
1592       }
1593 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,void (*func)(Dali::Toolkit::TextEditor)){
1594           self->Disconnect( func );
1595       }
1596 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,Dali::Toolkit::TextEditor arg){
1597           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1598 /*@SWIG@*/ self->Emit( arg );
1599       }
1600 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1601          return self->Empty();
1602       }
1603 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1604         return self->GetConnectionCount();
1605       }
1606 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::TextField) > *self,void (*func)(Dali::Toolkit::TextField)){
1607           self->Connect( func );
1608       }
1609 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::TextField) > *self,void (*func)(Dali::Toolkit::TextField)){
1610           self->Disconnect( func );
1611       }
1612 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextField) > *self,Dali::Toolkit::TextField arg){
1613           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1614 /*@SWIG@*/ self->Emit( arg );
1615       }
1616 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1617          return self->Empty();
1618       }
1619 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1620         return self->GetConnectionCount();
1621       }
1622 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1623         self->Connect( func );
1624       }
1625 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1626         self->Disconnect( func );
1627       }
1628 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,Dali::Toolkit::Control arg1,Dali::KeyEvent const &arg2){
1629         return self->Emit( arg1, arg2 );
1630       }
1631 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1632          return self->Empty();
1633       }
1634 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1635         return self->GetConnectionCount();
1636       }
1637 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1638           self->Connect( func );
1639       }
1640 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1641           self->Disconnect( func );
1642       }
1643 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1644           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1645 /*@SWIG@*/ self->Emit( arg );
1646       }
1647 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1648          return self->Empty();
1649       }
1650 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1651         return self->GetConnectionCount();
1652       }
1653 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1654           self->Connect( func );
1655       }
1656 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1657           self->Disconnect( func );
1658       }
1659 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,Dali::Toolkit::VideoView &arg){
1660           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1661 /*@SWIG@*/ self->Emit( arg );
1662       }
1663 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1664          return self->Empty();
1665       }
1666 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1667         return self->GetConnectionCount();
1668       }
1669 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1670         self->Connect( func );
1671       }
1672 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1673         self->Disconnect( func );
1674       }
1675 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,Dali::Toolkit::Slider arg1,float arg2){
1676         return self->Emit( arg1, arg2 );
1677       }
1678 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1679          return self->Empty();
1680       }
1681 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1682         return self->GetConnectionCount();
1683       }
1684 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1685         self->Connect( func );
1686       }
1687 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1688         self->Disconnect( func );
1689       }
1690 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,Dali::Toolkit::Slider arg1,int arg2){
1691         return self->Emit( arg1, arg2 );
1692       }
1693
1694
1695 /* ---------------------------------------------------
1696  * C++ director class methods
1697  * --------------------------------------------------- */
1698
1699 #include "dali_wrap.h"
1700
1701 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1702   swig_init_callbacks();
1703 }
1704
1705 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1706
1707 }
1708
1709
1710 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1711   int jdepth  ;
1712
1713   if (!swig_callbackOnStageConnection) {
1714     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1715     return;
1716   } else {
1717     jdepth = depth;
1718     swig_callbackOnStageConnection(jdepth);
1719   }
1720 }
1721
1722 void SwigDirector_ViewImpl::OnStageDisconnection() {
1723   if (!swig_callbackOnStageDisconnection) {
1724     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1725     return;
1726   } else {
1727     swig_callbackOnStageDisconnection();
1728   }
1729 }
1730
1731 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1732   void * jchild = 0 ;
1733
1734   if (!swig_callbackOnChildAdd) {
1735     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1736     return;
1737   } else {
1738     jchild = (Dali::Actor *) &child;
1739     swig_callbackOnChildAdd(jchild);
1740   }
1741 }
1742
1743 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1744   void * jchild = 0 ;
1745
1746   if (!swig_callbackOnChildRemove) {
1747     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1748     return;
1749   } else {
1750     jchild = (Dali::Actor *) &child;
1751     swig_callbackOnChildRemove(jchild);
1752   }
1753 }
1754
1755 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1756   int jindex  ;
1757   void * jpropertyValue  ;
1758
1759   if (!swig_callbackOnPropertySet) {
1760     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1761     return;
1762   } else {
1763     jindex = index;
1764     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1765     swig_callbackOnPropertySet(jindex, jpropertyValue);
1766   }
1767 }
1768
1769 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1770   void * jtargetSize = 0 ;
1771
1772   if (!swig_callbackOnSizeSet) {
1773     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1774     return;
1775   } else {
1776     jtargetSize = (Dali::Vector3 *) &targetSize;
1777     swig_callbackOnSizeSet(jtargetSize);
1778   }
1779 }
1780
1781 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1782   void * janimation = 0 ;
1783   void * jtargetSize = 0 ;
1784
1785   if (!swig_callbackOnSizeAnimation) {
1786     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1787     return;
1788   } else {
1789     janimation = (Dali::Animation *) &animation;
1790     jtargetSize = (Dali::Vector3 *) &targetSize;
1791     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1792   }
1793 }
1794
1795 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1796   bool c_result = SwigValueInit< bool >() ;
1797   unsigned int jresult = 0 ;
1798   void * jarg0 = 0 ;
1799
1800   if (!swig_callbackOnTouchEvent) {
1801     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1802   } else {
1803     jarg0 = (Dali::TouchEvent *) &event;
1804     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1805     c_result = jresult ? true : false;
1806   }
1807   return c_result;
1808 }
1809
1810 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1811   bool c_result = SwigValueInit< bool >() ;
1812   unsigned int jresult = 0 ;
1813   void * jarg0 = 0 ;
1814
1815   if (!swig_callbackOnHoverEvent) {
1816     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1817   } else {
1818     jarg0 = (Dali::HoverEvent *) &event;
1819     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1820     c_result = jresult ? true : false;
1821   }
1822   return c_result;
1823 }
1824
1825 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1826   bool c_result = SwigValueInit< bool >() ;
1827   unsigned int jresult = 0 ;
1828   void * jarg0 = 0 ;
1829
1830   if (!swig_callbackOnKeyEvent) {
1831     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1832   } else {
1833     jarg0 = (Dali::KeyEvent *) &event;
1834     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1835     c_result = jresult ? true : false;
1836   }
1837   return c_result;
1838 }
1839
1840 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1841   bool c_result = SwigValueInit< bool >() ;
1842   unsigned int jresult = 0 ;
1843   void * jarg0 = 0 ;
1844
1845   if (!swig_callbackOnWheelEvent) {
1846     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1847   } else {
1848     jarg0 = (Dali::WheelEvent *) &event;
1849     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1850     c_result = jresult ? true : false;
1851   }
1852   return c_result;
1853 }
1854
1855 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1856   void * jsize = 0 ;
1857   void * jcontainer = 0 ;
1858
1859   if (!swig_callbackOnRelayout) {
1860     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1861     return;
1862   } else {
1863     jsize = (Dali::Vector2 *) &size;
1864     jcontainer = (Dali::RelayoutContainer *) &container;
1865     swig_callbackOnRelayout(jsize, jcontainer);
1866   }
1867 }
1868
1869 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1870   int jpolicy  ;
1871   int jdimension  ;
1872
1873   if (!swig_callbackOnSetResizePolicy) {
1874     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1875     return;
1876   } else {
1877     jpolicy = (int)policy;
1878     jdimension = (int)dimension;
1879     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1880   }
1881 }
1882
1883 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1884   Dali::Vector3 c_result ;
1885   void * jresult = 0 ;
1886
1887   if (!swig_callbackGetNaturalSize) {
1888     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1889   } else {
1890     jresult = (void *) swig_callbackGetNaturalSize();
1891     if (!jresult) {
1892       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1893       return c_result;
1894     }
1895     c_result = *(Dali::Vector3 *)jresult;
1896   }
1897   return c_result;
1898 }
1899
1900 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1901   float c_result = SwigValueInit< float >() ;
1902   float jresult = 0 ;
1903   void * jchild = 0 ;
1904   int jdimension  ;
1905
1906   if (!swig_callbackCalculateChildSize) {
1907     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1908   } else {
1909     jchild = (Dali::Actor *) &child;
1910     jdimension = (int)dimension;
1911     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1912     c_result = (float)jresult;
1913   }
1914   return c_result;
1915 }
1916
1917 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
1918   float c_result = SwigValueInit< float >() ;
1919   float jresult = 0 ;
1920   float jwidth  ;
1921
1922   if (!swig_callbackGetHeightForWidth) {
1923     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
1924   } else {
1925     jwidth = width;
1926     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
1927     c_result = (float)jresult;
1928   }
1929   return c_result;
1930 }
1931
1932 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
1933   float c_result = SwigValueInit< float >() ;
1934   float jresult = 0 ;
1935   float jheight  ;
1936
1937   if (!swig_callbackGetWidthForHeight) {
1938     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
1939   } else {
1940     jheight = height;
1941     jresult = (float) swig_callbackGetWidthForHeight(jheight);
1942     c_result = (float)jresult;
1943   }
1944   return c_result;
1945 }
1946
1947 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
1948   bool c_result = SwigValueInit< bool >() ;
1949   unsigned int jresult = 0 ;
1950   int jdimension  ;
1951
1952   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
1953     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
1954   } else {
1955     jdimension = (int)dimension;
1956     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
1957     c_result = jresult ? true : false;
1958   }
1959   return c_result;
1960 }
1961
1962 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
1963   int jdimension  ;
1964
1965   if (!swig_callbackOnCalculateRelayoutSize) {
1966     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
1967     return;
1968   } else {
1969     jdimension = (int)dimension;
1970     swig_callbackOnCalculateRelayoutSize(jdimension);
1971   }
1972 }
1973
1974 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
1975   float jsize  ;
1976   int jdimension  ;
1977
1978   if (!swig_callbackOnLayoutNegotiated) {
1979     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
1980     return;
1981   } else {
1982     jsize = size;
1983     jdimension = (int)dimension;
1984     swig_callbackOnLayoutNegotiated(jsize, jdimension);
1985   }
1986 }
1987
1988 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
1989   return Dali::CustomActorImpl::GetExtension();
1990 }
1991
1992 void SwigDirector_ViewImpl::OnInitialize() {
1993   if (!swig_callbackOnInitialize) {
1994     Dali::Toolkit::Internal::Control::OnInitialize();
1995     return;
1996   } else {
1997     swig_callbackOnInitialize();
1998   }
1999 }
2000
2001 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2002   void * jchild = 0 ;
2003
2004   if (!swig_callbackOnControlChildAdd) {
2005     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2006     return;
2007   } else {
2008     jchild = (Dali::Actor *) &child;
2009     swig_callbackOnControlChildAdd(jchild);
2010   }
2011 }
2012
2013 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2014   void * jchild = 0 ;
2015
2016   if (!swig_callbackOnControlChildRemove) {
2017     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2018     return;
2019   } else {
2020     jchild = (Dali::Actor *) &child;
2021     swig_callbackOnControlChildRemove(jchild);
2022   }
2023 }
2024
2025 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2026   void * jstyleManager  ;
2027   int jchange  ;
2028
2029   if (!swig_callbackOnStyleChange) {
2030     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2031     return;
2032   } else {
2033     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2034     jchange = (int)change;
2035     swig_callbackOnStyleChange(jstyleManager, jchange);
2036   }
2037 }
2038
2039 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2040   bool c_result = SwigValueInit< bool >() ;
2041   unsigned int jresult = 0 ;
2042
2043   if (!swig_callbackOnAccessibilityActivated) {
2044     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2045   } else {
2046     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2047     c_result = jresult ? true : false;
2048   }
2049   return c_result;
2050 }
2051
2052 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2053   bool c_result = SwigValueInit< bool >() ;
2054   unsigned int jresult = 0 ;
2055   void * jgesture  ;
2056
2057   if (!swig_callbackOnAccessibilityPan) {
2058     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2059   } else {
2060     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2061     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2062     c_result = jresult ? true : false;
2063   }
2064   return c_result;
2065 }
2066
2067 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2068   bool c_result = SwigValueInit< bool >() ;
2069   unsigned int jresult = 0 ;
2070   void * jtouchEvent = 0 ;
2071
2072   if (!swig_callbackOnAccessibilityTouch) {
2073     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2074   } else {
2075     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2076     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2077     c_result = jresult ? true : false;
2078   }
2079   return c_result;
2080 }
2081
2082 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2083   bool c_result = SwigValueInit< bool >() ;
2084   unsigned int jresult = 0 ;
2085   unsigned int jisIncrease  ;
2086
2087   if (!swig_callbackOnAccessibilityValueChange) {
2088     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2089   } else {
2090     jisIncrease = isIncrease;
2091     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2092     c_result = jresult ? true : false;
2093   }
2094   return c_result;
2095 }
2096
2097 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2098   bool c_result = SwigValueInit< bool >() ;
2099   unsigned int jresult = 0 ;
2100
2101   if (!swig_callbackOnAccessibilityZoom) {
2102     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2103   } else {
2104     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2105     c_result = jresult ? true : false;
2106   }
2107   return c_result;
2108 }
2109
2110 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2111   if (!swig_callbackOnKeyInputFocusGained) {
2112     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2113     return;
2114   } else {
2115     swig_callbackOnKeyInputFocusGained();
2116   }
2117 }
2118
2119 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2120   if (!swig_callbackOnKeyInputFocusLost) {
2121     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2122     return;
2123   } else {
2124     swig_callbackOnKeyInputFocusLost();
2125   }
2126 }
2127
2128 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2129   Dali::Actor c_result ;
2130   void * jresult = 0 ;
2131   void * jcurrentFocusedActor  ;
2132   int jdirection  ;
2133   unsigned int jloopEnabled  ;
2134
2135   if (!swig_callbackGetNextKeyboardFocusableActor) {
2136     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2137   } else {
2138     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2139     jdirection = (int)direction;
2140     jloopEnabled = loopEnabled;
2141     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2142     if (!jresult) {
2143       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2144       return c_result;
2145     }
2146     c_result = *(Dali::Actor *)jresult;
2147   }
2148   return c_result;
2149 }
2150
2151 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2152   void * jcommitedFocusableActor  ;
2153
2154   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2155     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2156     return;
2157   } else {
2158     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2159     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2160   }
2161 }
2162
2163 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2164   bool c_result = SwigValueInit< bool >() ;
2165   unsigned int jresult = 0 ;
2166
2167   if (!swig_callbackOnKeyboardEnter) {
2168     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2169   } else {
2170     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2171     c_result = jresult ? true : false;
2172   }
2173   return c_result;
2174 }
2175
2176 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2177   void * jpinch = 0 ;
2178
2179   if (!swig_callbackOnPinch) {
2180     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2181     return;
2182   } else {
2183     jpinch = (Dali::PinchGesture *) &pinch;
2184     swig_callbackOnPinch(jpinch);
2185   }
2186 }
2187
2188 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2189   void * jpan = 0 ;
2190
2191   if (!swig_callbackOnPan) {
2192     Dali::Toolkit::Internal::Control::OnPan(pan);
2193     return;
2194   } else {
2195     jpan = (Dali::PanGesture *) &pan;
2196     swig_callbackOnPan(jpan);
2197   }
2198 }
2199
2200 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2201   void * jtap = 0 ;
2202
2203   if (!swig_callbackOnTap) {
2204     Dali::Toolkit::Internal::Control::OnTap(tap);
2205     return;
2206   } else {
2207     jtap = (Dali::TapGesture *) &tap;
2208     swig_callbackOnTap(jtap);
2209   }
2210 }
2211
2212 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2213   void * jlongPress = 0 ;
2214
2215   if (!swig_callbackOnLongPress) {
2216     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2217     return;
2218   } else {
2219     jlongPress = (Dali::LongPressGesture *) &longPress;
2220     swig_callbackOnLongPress(jlongPress);
2221   }
2222 }
2223
2224 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2225   void * jslotObserver = 0 ;
2226   void * jcallback = 0 ;
2227
2228   if (!swig_callbackSignalConnected) {
2229     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2230     return;
2231   } else {
2232     jslotObserver = (void *) slotObserver;
2233     jcallback = (void *) callback;
2234     swig_callbackSignalConnected(jslotObserver, jcallback);
2235   }
2236 }
2237
2238 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2239   void * jslotObserver = 0 ;
2240   void * jcallback = 0 ;
2241
2242   if (!swig_callbackSignalDisconnected) {
2243     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2244     return;
2245   } else {
2246     jslotObserver = (void *) slotObserver;
2247     jcallback = (void *) callback;
2248     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2249   }
2250 }
2251
2252 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2253   return Dali::Toolkit::Internal::Control::GetControlExtension();
2254 }
2255
2256 void SwigDirector_ViewImpl::swig_connect_director(SWIG_Callback0_t callbackOnStageConnection, SWIG_Callback1_t callbackOnStageDisconnection, SWIG_Callback2_t callbackOnChildAdd, SWIG_Callback3_t callbackOnChildRemove, SWIG_Callback4_t callbackOnPropertySet, SWIG_Callback5_t callbackOnSizeSet, SWIG_Callback6_t callbackOnSizeAnimation, SWIG_Callback7_t callbackOnTouchEvent, SWIG_Callback8_t callbackOnHoverEvent, SWIG_Callback9_t callbackOnKeyEvent, SWIG_Callback10_t callbackOnWheelEvent, SWIG_Callback11_t callbackOnRelayout, SWIG_Callback12_t callbackOnSetResizePolicy, SWIG_Callback13_t callbackGetNaturalSize, SWIG_Callback14_t callbackCalculateChildSize, SWIG_Callback15_t callbackGetHeightForWidth, SWIG_Callback16_t callbackGetWidthForHeight, SWIG_Callback17_t callbackRelayoutDependentOnChildren__SWIG_0, SWIG_Callback18_t callbackRelayoutDependentOnChildren__SWIG_1, SWIG_Callback19_t callbackOnCalculateRelayoutSize, SWIG_Callback20_t callbackOnLayoutNegotiated, SWIG_Callback21_t callbackOnInitialize, SWIG_Callback22_t callbackOnControlChildAdd, SWIG_Callback23_t callbackOnControlChildRemove, SWIG_Callback24_t callbackOnStyleChange, SWIG_Callback25_t callbackOnAccessibilityActivated, SWIG_Callback26_t callbackOnAccessibilityPan, SWIG_Callback27_t callbackOnAccessibilityTouch, SWIG_Callback28_t callbackOnAccessibilityValueChange, SWIG_Callback29_t callbackOnAccessibilityZoom, SWIG_Callback30_t callbackOnKeyInputFocusGained, SWIG_Callback31_t callbackOnKeyInputFocusLost, SWIG_Callback32_t callbackGetNextKeyboardFocusableActor, SWIG_Callback33_t callbackOnKeyboardFocusChangeCommitted, SWIG_Callback34_t callbackOnKeyboardEnter, SWIG_Callback35_t callbackOnPinch, SWIG_Callback36_t callbackOnPan, SWIG_Callback37_t callbackOnTap, SWIG_Callback38_t callbackOnLongPress, SWIG_Callback39_t callbackSignalConnected, SWIG_Callback40_t callbackSignalDisconnected) {
2257   swig_callbackOnStageConnection = callbackOnStageConnection;
2258   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2259   swig_callbackOnChildAdd = callbackOnChildAdd;
2260   swig_callbackOnChildRemove = callbackOnChildRemove;
2261   swig_callbackOnPropertySet = callbackOnPropertySet;
2262   swig_callbackOnSizeSet = callbackOnSizeSet;
2263   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2264   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2265   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2266   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2267   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2268   swig_callbackOnRelayout = callbackOnRelayout;
2269   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2270   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2271   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2272   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2273   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2274   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2275   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2276   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2277   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2278   swig_callbackOnInitialize = callbackOnInitialize;
2279   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2280   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2281   swig_callbackOnStyleChange = callbackOnStyleChange;
2282   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2283   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2284   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2285   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2286   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2287   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2288   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2289   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2290   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2291   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2292   swig_callbackOnPinch = callbackOnPinch;
2293   swig_callbackOnPan = callbackOnPan;
2294   swig_callbackOnTap = callbackOnTap;
2295   swig_callbackOnLongPress = callbackOnLongPress;
2296   swig_callbackSignalConnected = callbackSignalConnected;
2297   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2298 }
2299
2300 void SwigDirector_ViewImpl::swig_init_callbacks() {
2301   swig_callbackOnStageConnection = 0;
2302   swig_callbackOnStageDisconnection = 0;
2303   swig_callbackOnChildAdd = 0;
2304   swig_callbackOnChildRemove = 0;
2305   swig_callbackOnPropertySet = 0;
2306   swig_callbackOnSizeSet = 0;
2307   swig_callbackOnSizeAnimation = 0;
2308   swig_callbackOnTouchEvent = 0;
2309   swig_callbackOnHoverEvent = 0;
2310   swig_callbackOnKeyEvent = 0;
2311   swig_callbackOnWheelEvent = 0;
2312   swig_callbackOnRelayout = 0;
2313   swig_callbackOnSetResizePolicy = 0;
2314   swig_callbackGetNaturalSize = 0;
2315   swig_callbackCalculateChildSize = 0;
2316   swig_callbackGetHeightForWidth = 0;
2317   swig_callbackGetWidthForHeight = 0;
2318   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2319   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2320   swig_callbackOnCalculateRelayoutSize = 0;
2321   swig_callbackOnLayoutNegotiated = 0;
2322   swig_callbackOnInitialize = 0;
2323   swig_callbackOnControlChildAdd = 0;
2324   swig_callbackOnControlChildRemove = 0;
2325   swig_callbackOnStyleChange = 0;
2326   swig_callbackOnAccessibilityActivated = 0;
2327   swig_callbackOnAccessibilityPan = 0;
2328   swig_callbackOnAccessibilityTouch = 0;
2329   swig_callbackOnAccessibilityValueChange = 0;
2330   swig_callbackOnAccessibilityZoom = 0;
2331   swig_callbackOnKeyInputFocusGained = 0;
2332   swig_callbackOnKeyInputFocusLost = 0;
2333   swig_callbackGetNextKeyboardFocusableActor = 0;
2334   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2335   swig_callbackOnKeyboardEnter = 0;
2336   swig_callbackOnPinch = 0;
2337   swig_callbackOnPan = 0;
2338   swig_callbackOnTap = 0;
2339   swig_callbackOnLongPress = 0;
2340   swig_callbackSignalConnected = 0;
2341   swig_callbackSignalDisconnected = 0;
2342 }
2343
2344 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2345   swig_init_callbacks();
2346 }
2347
2348 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2349
2350 }
2351
2352
2353 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2354   unsigned int c_result = SwigValueInit< unsigned int >() ;
2355   unsigned int jresult = 0 ;
2356
2357   if (!swig_callbackGetNumberOfItems) {
2358     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2359   } else {
2360     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2361     c_result = (unsigned int)jresult;
2362   }
2363   return c_result;
2364 }
2365
2366 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2367   Dali::Actor c_result ;
2368   void * jresult = 0 ;
2369   unsigned int jitemId  ;
2370
2371   if (!swig_callbackNewItem) {
2372     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2373   } else {
2374     jitemId = itemId;
2375     jresult = (void *) swig_callbackNewItem(jitemId);
2376     if (!jresult) {
2377       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2378       return c_result;
2379     }
2380     c_result = *(Dali::Actor *)jresult;
2381   }
2382   return c_result;
2383 }
2384
2385 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2386   unsigned int jitemId  ;
2387   void * jactor  ;
2388
2389   if (!swig_callbackItemReleased) {
2390     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2391     return;
2392   } else {
2393     jitemId = itemId;
2394     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2395     swig_callbackItemReleased(jitemId, jactor);
2396   }
2397 }
2398
2399 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2400   return Dali::Toolkit::ItemFactory::GetExtension();
2401 }
2402
2403 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2404   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2405   swig_callbackNewItem = callbackNewItem;
2406   swig_callbackItemReleased = callbackItemReleased;
2407 }
2408
2409 void SwigDirector_ItemFactory::swig_init_callbacks() {
2410   swig_callbackGetNumberOfItems = 0;
2411   swig_callbackNewItem = 0;
2412   swig_callbackItemReleased = 0;
2413 }
2414
2415 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2416   swig_init_callbacks();
2417 }
2418
2419 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2420
2421 }
2422
2423
2424 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2425   Dali::Actor c_result ;
2426   void * jresult = 0 ;
2427   void * jcurrent  ;
2428   void * jproposed  ;
2429   int jdirection  ;
2430
2431   if (!swig_callbackGetNextFocusableActor) {
2432     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2433   } else {
2434     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2435     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2436     jdirection = (int)direction;
2437     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2438     if (!jresult) {
2439       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2440       return c_result;
2441     }
2442     c_result = *(Dali::Actor *)jresult;
2443   }
2444   return c_result;
2445 }
2446
2447 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2448   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2449 }
2450
2451 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2452   swig_callbackGetNextFocusableActor = 0;
2453 }
2454
2455
2456 #ifdef __cplusplus
2457 extern "C" {
2458 #endif
2459
2460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2461   void * jresult ;
2462   floatp *result = 0 ;
2463
2464   {
2465     try {
2466       result = (floatp *)new_floatp();
2467     } catch (std::out_of_range& e) {
2468       {
2469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2470       };
2471     } catch (std::exception& e) {
2472       {
2473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2474       };
2475     } catch (...) {
2476       {
2477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2478       };
2479     }
2480   }
2481   jresult = (void *)result;
2482   return jresult;
2483 }
2484
2485
2486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2487   floatp *arg1 = (floatp *) 0 ;
2488
2489   arg1 = (floatp *)jarg1;
2490   {
2491     try {
2492       delete_floatp(arg1);
2493     } catch (std::out_of_range& e) {
2494       {
2495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2496       };
2497     } catch (std::exception& e) {
2498       {
2499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2500       };
2501     } catch (...) {
2502       {
2503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2504       };
2505     }
2506   }
2507 }
2508
2509
2510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2511   floatp *arg1 = (floatp *) 0 ;
2512   float arg2 ;
2513
2514   arg1 = (floatp *)jarg1;
2515   arg2 = (float)jarg2;
2516   {
2517     try {
2518       floatp_assign(arg1,arg2);
2519     } catch (std::out_of_range& e) {
2520       {
2521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2522       };
2523     } catch (std::exception& e) {
2524       {
2525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2526       };
2527     } catch (...) {
2528       {
2529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2530       };
2531     }
2532   }
2533 }
2534
2535
2536 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2537   float jresult ;
2538   floatp *arg1 = (floatp *) 0 ;
2539   float result;
2540
2541   arg1 = (floatp *)jarg1;
2542   {
2543     try {
2544       result = (float)floatp_value(arg1);
2545     } catch (std::out_of_range& e) {
2546       {
2547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2548       };
2549     } catch (std::exception& e) {
2550       {
2551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2552       };
2553     } catch (...) {
2554       {
2555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2556       };
2557     }
2558   }
2559   jresult = result;
2560   return jresult;
2561 }
2562
2563
2564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2565   void * jresult ;
2566   floatp *arg1 = (floatp *) 0 ;
2567   float *result = 0 ;
2568
2569   arg1 = (floatp *)jarg1;
2570   {
2571     try {
2572       result = (float *)floatp_cast(arg1);
2573     } catch (std::out_of_range& e) {
2574       {
2575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2576       };
2577     } catch (std::exception& e) {
2578       {
2579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2580       };
2581     } catch (...) {
2582       {
2583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2584       };
2585     }
2586   }
2587   jresult = (void *)result;
2588   return jresult;
2589 }
2590
2591
2592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2593   void * jresult ;
2594   float *arg1 = (float *) 0 ;
2595   floatp *result = 0 ;
2596
2597   arg1 = (float *)jarg1;
2598   {
2599     try {
2600       result = (floatp *)floatp_frompointer(arg1);
2601     } catch (std::out_of_range& e) {
2602       {
2603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2604       };
2605     } catch (std::exception& e) {
2606       {
2607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2608       };
2609     } catch (...) {
2610       {
2611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2612       };
2613     }
2614   }
2615   jresult = (void *)result;
2616   return jresult;
2617 }
2618
2619
2620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2621   void * jresult ;
2622   intp *result = 0 ;
2623
2624   {
2625     try {
2626       result = (intp *)new_intp();
2627     } catch (std::out_of_range& e) {
2628       {
2629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2630       };
2631     } catch (std::exception& e) {
2632       {
2633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2634       };
2635     } catch (...) {
2636       {
2637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2638       };
2639     }
2640   }
2641   jresult = (void *)result;
2642   return jresult;
2643 }
2644
2645
2646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2647   intp *arg1 = (intp *) 0 ;
2648
2649   arg1 = (intp *)jarg1;
2650   {
2651     try {
2652       delete_intp(arg1);
2653     } catch (std::out_of_range& e) {
2654       {
2655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2656       };
2657     } catch (std::exception& e) {
2658       {
2659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2660       };
2661     } catch (...) {
2662       {
2663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2664       };
2665     }
2666   }
2667 }
2668
2669
2670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2671   intp *arg1 = (intp *) 0 ;
2672   int arg2 ;
2673
2674   arg1 = (intp *)jarg1;
2675   arg2 = (int)jarg2;
2676   {
2677     try {
2678       intp_assign(arg1,arg2);
2679     } catch (std::out_of_range& e) {
2680       {
2681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2682       };
2683     } catch (std::exception& e) {
2684       {
2685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2686       };
2687     } catch (...) {
2688       {
2689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2690       };
2691     }
2692   }
2693 }
2694
2695
2696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2697   int jresult ;
2698   intp *arg1 = (intp *) 0 ;
2699   int result;
2700
2701   arg1 = (intp *)jarg1;
2702   {
2703     try {
2704       result = (int)intp_value(arg1);
2705     } catch (std::out_of_range& e) {
2706       {
2707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2708       };
2709     } catch (std::exception& e) {
2710       {
2711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2712       };
2713     } catch (...) {
2714       {
2715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2716       };
2717     }
2718   }
2719   jresult = result;
2720   return jresult;
2721 }
2722
2723
2724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2725   void * jresult ;
2726   intp *arg1 = (intp *) 0 ;
2727   int *result = 0 ;
2728
2729   arg1 = (intp *)jarg1;
2730   {
2731     try {
2732       result = (int *)intp_cast(arg1);
2733     } catch (std::out_of_range& e) {
2734       {
2735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2736       };
2737     } catch (std::exception& e) {
2738       {
2739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2740       };
2741     } catch (...) {
2742       {
2743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2744       };
2745     }
2746   }
2747   jresult = (void *)result;
2748   return jresult;
2749 }
2750
2751
2752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2753   void * jresult ;
2754   int *arg1 = (int *) 0 ;
2755   intp *result = 0 ;
2756
2757   arg1 = (int *)jarg1;
2758   {
2759     try {
2760       result = (intp *)intp_frompointer(arg1);
2761     } catch (std::out_of_range& e) {
2762       {
2763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2764       };
2765     } catch (std::exception& e) {
2766       {
2767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2768       };
2769     } catch (...) {
2770       {
2771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2772       };
2773     }
2774   }
2775   jresult = (void *)result;
2776   return jresult;
2777 }
2778
2779
2780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2781   void * jresult ;
2782   doublep *result = 0 ;
2783
2784   {
2785     try {
2786       result = (doublep *)new_doublep();
2787     } catch (std::out_of_range& e) {
2788       {
2789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2790       };
2791     } catch (std::exception& e) {
2792       {
2793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2794       };
2795     } catch (...) {
2796       {
2797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2798       };
2799     }
2800   }
2801   jresult = (void *)result;
2802   return jresult;
2803 }
2804
2805
2806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2807   doublep *arg1 = (doublep *) 0 ;
2808
2809   arg1 = (doublep *)jarg1;
2810   {
2811     try {
2812       delete_doublep(arg1);
2813     } catch (std::out_of_range& e) {
2814       {
2815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2816       };
2817     } catch (std::exception& e) {
2818       {
2819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2820       };
2821     } catch (...) {
2822       {
2823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2824       };
2825     }
2826   }
2827 }
2828
2829
2830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2831   doublep *arg1 = (doublep *) 0 ;
2832   double arg2 ;
2833
2834   arg1 = (doublep *)jarg1;
2835   arg2 = (double)jarg2;
2836   {
2837     try {
2838       doublep_assign(arg1,arg2);
2839     } catch (std::out_of_range& e) {
2840       {
2841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2842       };
2843     } catch (std::exception& e) {
2844       {
2845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2846       };
2847     } catch (...) {
2848       {
2849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2850       };
2851     }
2852   }
2853 }
2854
2855
2856 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2857   double jresult ;
2858   doublep *arg1 = (doublep *) 0 ;
2859   double result;
2860
2861   arg1 = (doublep *)jarg1;
2862   {
2863     try {
2864       result = (double)doublep_value(arg1);
2865     } catch (std::out_of_range& e) {
2866       {
2867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2868       };
2869     } catch (std::exception& e) {
2870       {
2871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2872       };
2873     } catch (...) {
2874       {
2875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2876       };
2877     }
2878   }
2879   jresult = result;
2880   return jresult;
2881 }
2882
2883
2884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2885   void * jresult ;
2886   doublep *arg1 = (doublep *) 0 ;
2887   double *result = 0 ;
2888
2889   arg1 = (doublep *)jarg1;
2890   {
2891     try {
2892       result = (double *)doublep_cast(arg1);
2893     } catch (std::out_of_range& e) {
2894       {
2895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2896       };
2897     } catch (std::exception& e) {
2898       {
2899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2900       };
2901     } catch (...) {
2902       {
2903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2904       };
2905     }
2906   }
2907   jresult = (void *)result;
2908   return jresult;
2909 }
2910
2911
2912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2913   void * jresult ;
2914   double *arg1 = (double *) 0 ;
2915   doublep *result = 0 ;
2916
2917   arg1 = (double *)jarg1;
2918   {
2919     try {
2920       result = (doublep *)doublep_frompointer(arg1);
2921     } catch (std::out_of_range& e) {
2922       {
2923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2924       };
2925     } catch (std::exception& e) {
2926       {
2927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2928       };
2929     } catch (...) {
2930       {
2931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2932       };
2933     }
2934   }
2935   jresult = (void *)result;
2936   return jresult;
2937 }
2938
2939
2940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
2941   void * jresult ;
2942   uintp *result = 0 ;
2943
2944   {
2945     try {
2946       result = (uintp *)new_uintp();
2947     } catch (std::out_of_range& e) {
2948       {
2949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2950       };
2951     } catch (std::exception& e) {
2952       {
2953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2954       };
2955     } catch (...) {
2956       {
2957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2958       };
2959     }
2960   }
2961   jresult = (void *)result;
2962   return jresult;
2963 }
2964
2965
2966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
2967   uintp *arg1 = (uintp *) 0 ;
2968
2969   arg1 = (uintp *)jarg1;
2970   {
2971     try {
2972       delete_uintp(arg1);
2973     } catch (std::out_of_range& e) {
2974       {
2975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2976       };
2977     } catch (std::exception& e) {
2978       {
2979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2980       };
2981     } catch (...) {
2982       {
2983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2984       };
2985     }
2986   }
2987 }
2988
2989
2990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
2991   uintp *arg1 = (uintp *) 0 ;
2992   unsigned int arg2 ;
2993
2994   arg1 = (uintp *)jarg1;
2995   arg2 = (unsigned int)jarg2;
2996   {
2997     try {
2998       uintp_assign(arg1,arg2);
2999     } catch (std::out_of_range& e) {
3000       {
3001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3002       };
3003     } catch (std::exception& e) {
3004       {
3005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3006       };
3007     } catch (...) {
3008       {
3009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3010       };
3011     }
3012   }
3013 }
3014
3015
3016 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3017   unsigned int jresult ;
3018   uintp *arg1 = (uintp *) 0 ;
3019   unsigned int result;
3020
3021   arg1 = (uintp *)jarg1;
3022   {
3023     try {
3024       result = (unsigned int)uintp_value(arg1);
3025     } catch (std::out_of_range& e) {
3026       {
3027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3028       };
3029     } catch (std::exception& e) {
3030       {
3031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3032       };
3033     } catch (...) {
3034       {
3035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3036       };
3037     }
3038   }
3039   jresult = result;
3040   return jresult;
3041 }
3042
3043
3044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3045   void * jresult ;
3046   uintp *arg1 = (uintp *) 0 ;
3047   unsigned int *result = 0 ;
3048
3049   arg1 = (uintp *)jarg1;
3050   {
3051     try {
3052       result = (unsigned int *)uintp_cast(arg1);
3053     } catch (std::out_of_range& e) {
3054       {
3055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3056       };
3057     } catch (std::exception& e) {
3058       {
3059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3060       };
3061     } catch (...) {
3062       {
3063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3064       };
3065     }
3066   }
3067   jresult = (void *)result;
3068   return jresult;
3069 }
3070
3071
3072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3073   void * jresult ;
3074   unsigned int *arg1 = (unsigned int *) 0 ;
3075   uintp *result = 0 ;
3076
3077   arg1 = (unsigned int *)jarg1;
3078   {
3079     try {
3080       result = (uintp *)uintp_frompointer(arg1);
3081     } catch (std::out_of_range& e) {
3082       {
3083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3084       };
3085     } catch (std::exception& e) {
3086       {
3087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3088       };
3089     } catch (...) {
3090       {
3091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3092       };
3093     }
3094   }
3095   jresult = (void *)result;
3096   return jresult;
3097 }
3098
3099
3100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3101   void * jresult ;
3102   ushortp *result = 0 ;
3103
3104   {
3105     try {
3106       result = (ushortp *)new_ushortp();
3107     } catch (std::out_of_range& e) {
3108       {
3109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3110       };
3111     } catch (std::exception& e) {
3112       {
3113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3114       };
3115     } catch (...) {
3116       {
3117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3118       };
3119     }
3120   }
3121   jresult = (void *)result;
3122   return jresult;
3123 }
3124
3125
3126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3127   ushortp *arg1 = (ushortp *) 0 ;
3128
3129   arg1 = (ushortp *)jarg1;
3130   {
3131     try {
3132       delete_ushortp(arg1);
3133     } catch (std::out_of_range& e) {
3134       {
3135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3136       };
3137     } catch (std::exception& e) {
3138       {
3139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3140       };
3141     } catch (...) {
3142       {
3143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3144       };
3145     }
3146   }
3147 }
3148
3149
3150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3151   ushortp *arg1 = (ushortp *) 0 ;
3152   unsigned short arg2 ;
3153
3154   arg1 = (ushortp *)jarg1;
3155   arg2 = (unsigned short)jarg2;
3156   {
3157     try {
3158       ushortp_assign(arg1,arg2);
3159     } catch (std::out_of_range& e) {
3160       {
3161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3162       };
3163     } catch (std::exception& e) {
3164       {
3165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3166       };
3167     } catch (...) {
3168       {
3169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3170       };
3171     }
3172   }
3173 }
3174
3175
3176 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3177   unsigned short jresult ;
3178   ushortp *arg1 = (ushortp *) 0 ;
3179   unsigned short result;
3180
3181   arg1 = (ushortp *)jarg1;
3182   {
3183     try {
3184       result = (unsigned short)ushortp_value(arg1);
3185     } catch (std::out_of_range& e) {
3186       {
3187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3188       };
3189     } catch (std::exception& e) {
3190       {
3191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3192       };
3193     } catch (...) {
3194       {
3195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3196       };
3197     }
3198   }
3199   jresult = result;
3200   return jresult;
3201 }
3202
3203
3204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3205   void * jresult ;
3206   ushortp *arg1 = (ushortp *) 0 ;
3207   unsigned short *result = 0 ;
3208
3209   arg1 = (ushortp *)jarg1;
3210   {
3211     try {
3212       result = (unsigned short *)ushortp_cast(arg1);
3213     } catch (std::out_of_range& e) {
3214       {
3215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3216       };
3217     } catch (std::exception& e) {
3218       {
3219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3220       };
3221     } catch (...) {
3222       {
3223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3224       };
3225     }
3226   }
3227   jresult = (void *)result;
3228   return jresult;
3229 }
3230
3231
3232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3233   void * jresult ;
3234   unsigned short *arg1 = (unsigned short *) 0 ;
3235   ushortp *result = 0 ;
3236
3237   arg1 = (unsigned short *)jarg1;
3238   {
3239     try {
3240       result = (ushortp *)ushortp_frompointer(arg1);
3241     } catch (std::out_of_range& e) {
3242       {
3243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3244       };
3245     } catch (std::exception& e) {
3246       {
3247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3248       };
3249     } catch (...) {
3250       {
3251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3252       };
3253     }
3254   }
3255   jresult = (void *)result;
3256   return jresult;
3257 }
3258
3259
3260 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3261   unsigned int jresult ;
3262   int arg1 ;
3263   unsigned int result;
3264
3265   arg1 = (int)jarg1;
3266   {
3267     try {
3268       result = (unsigned int)int_to_uint(arg1);
3269     } catch (std::out_of_range& e) {
3270       {
3271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3272       };
3273     } catch (std::exception& e) {
3274       {
3275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3276       };
3277     } catch (...) {
3278       {
3279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3280       };
3281     }
3282   }
3283   jresult = result;
3284   return jresult;
3285 }
3286
3287
3288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3289   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3290
3291   arg1 = (Dali::RefObject *)jarg1;
3292   {
3293     try {
3294       (arg1)->Reference();
3295     } catch (std::out_of_range& e) {
3296       {
3297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3298       };
3299     } catch (std::exception& e) {
3300       {
3301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3302       };
3303     } catch (...) {
3304       {
3305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3306       };
3307     }
3308   }
3309 }
3310
3311
3312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3313   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3314
3315   arg1 = (Dali::RefObject *)jarg1;
3316   {
3317     try {
3318       (arg1)->Unreference();
3319     } catch (std::out_of_range& e) {
3320       {
3321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3322       };
3323     } catch (std::exception& e) {
3324       {
3325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3326       };
3327     } catch (...) {
3328       {
3329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3330       };
3331     }
3332   }
3333 }
3334
3335
3336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3337   int jresult ;
3338   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3339   int result;
3340
3341   arg1 = (Dali::RefObject *)jarg1;
3342   {
3343     try {
3344       result = (int)(arg1)->ReferenceCount();
3345     } catch (std::out_of_range& e) {
3346       {
3347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3348       };
3349     } catch (std::exception& e) {
3350       {
3351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3352       };
3353     } catch (...) {
3354       {
3355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3356       };
3357     }
3358   }
3359   jresult = result;
3360   return jresult;
3361 }
3362
3363
3364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3365   void * jresult ;
3366   Dali::Any *result = 0 ;
3367
3368   {
3369     try {
3370       result = (Dali::Any *)new Dali::Any();
3371     } catch (std::out_of_range& e) {
3372       {
3373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3374       };
3375     } catch (std::exception& e) {
3376       {
3377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3378       };
3379     } catch (...) {
3380       {
3381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3382       };
3383     }
3384   }
3385   jresult = (void *)result;
3386   return jresult;
3387 }
3388
3389
3390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3391   Dali::Any *arg1 = (Dali::Any *) 0 ;
3392
3393   arg1 = (Dali::Any *)jarg1;
3394   {
3395     try {
3396       delete arg1;
3397     } catch (std::out_of_range& e) {
3398       {
3399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3400       };
3401     } catch (std::exception& e) {
3402       {
3403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3404       };
3405     } catch (...) {
3406       {
3407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3408       };
3409     }
3410   }
3411 }
3412
3413
3414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3415   char *arg1 = (char *) 0 ;
3416
3417   arg1 = (char *)jarg1;
3418   {
3419     try {
3420       Dali::Any::AssertAlways((char const *)arg1);
3421     } catch (std::out_of_range& e) {
3422       {
3423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3424       };
3425     } catch (std::exception& e) {
3426       {
3427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3428       };
3429     } catch (...) {
3430       {
3431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3432       };
3433     }
3434   }
3435 }
3436
3437
3438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3439   void * jresult ;
3440   Dali::Any *arg1 = 0 ;
3441   Dali::Any *result = 0 ;
3442
3443   arg1 = (Dali::Any *)jarg1;
3444   if (!arg1) {
3445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3446     return 0;
3447   }
3448   {
3449     try {
3450       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3451     } catch (std::out_of_range& e) {
3452       {
3453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3454       };
3455     } catch (std::exception& e) {
3456       {
3457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3458       };
3459     } catch (...) {
3460       {
3461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3462       };
3463     }
3464   }
3465   jresult = (void *)result;
3466   return jresult;
3467 }
3468
3469
3470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3471   void * jresult ;
3472   Dali::Any *arg1 = (Dali::Any *) 0 ;
3473   Dali::Any *arg2 = 0 ;
3474   Dali::Any *result = 0 ;
3475
3476   arg1 = (Dali::Any *)jarg1;
3477   arg2 = (Dali::Any *)jarg2;
3478   if (!arg2) {
3479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3480     return 0;
3481   }
3482   {
3483     try {
3484       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3485     } catch (std::out_of_range& e) {
3486       {
3487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3488       };
3489     } catch (std::exception& e) {
3490       {
3491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3492       };
3493     } catch (...) {
3494       {
3495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3496       };
3497     }
3498   }
3499   jresult = (void *)result;
3500   return jresult;
3501 }
3502
3503
3504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3505   void * jresult ;
3506   Dali::Any *arg1 = (Dali::Any *) 0 ;
3507   std::type_info *result = 0 ;
3508
3509   arg1 = (Dali::Any *)jarg1;
3510   {
3511     try {
3512       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3513     } catch (std::out_of_range& e) {
3514       {
3515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3516       };
3517     } catch (std::exception& e) {
3518       {
3519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3520       };
3521     } catch (...) {
3522       {
3523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3524       };
3525     }
3526   }
3527   jresult = (void *)result;
3528   return jresult;
3529 }
3530
3531
3532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3533   unsigned int jresult ;
3534   Dali::Any *arg1 = (Dali::Any *) 0 ;
3535   bool result;
3536
3537   arg1 = (Dali::Any *)jarg1;
3538   {
3539     try {
3540       result = (bool)((Dali::Any const *)arg1)->Empty();
3541     } catch (std::out_of_range& e) {
3542       {
3543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3544       };
3545     } catch (std::exception& e) {
3546       {
3547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3548       };
3549     } catch (...) {
3550       {
3551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3552       };
3553     }
3554   }
3555   jresult = result;
3556   return jresult;
3557 }
3558
3559
3560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3561   void * jresult ;
3562   std::type_info *arg1 = 0 ;
3563   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3564   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3565   Dali::Any::AnyContainerBase *result = 0 ;
3566
3567   arg1 = (std::type_info *)jarg1;
3568   if (!arg1) {
3569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3570     return 0;
3571   }
3572   arg2 = (Dali::Any::CloneFunc)jarg2;
3573   arg3 = (Dali::Any::DeleteFunc)jarg3;
3574   {
3575     try {
3576       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3577     } catch (std::out_of_range& e) {
3578       {
3579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3580       };
3581     } catch (std::exception& e) {
3582       {
3583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3584       };
3585     } catch (...) {
3586       {
3587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3588       };
3589     }
3590   }
3591   jresult = (void *)result;
3592   return jresult;
3593 }
3594
3595
3596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3597   void * jresult ;
3598   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3599   std::type_info *result = 0 ;
3600
3601   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3602   {
3603     try {
3604       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3605     } catch (std::out_of_range& e) {
3606       {
3607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3608       };
3609     } catch (std::exception& e) {
3610       {
3611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3612       };
3613     } catch (...) {
3614       {
3615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3616       };
3617     }
3618   }
3619   jresult = (void *)result;
3620   return jresult;
3621 }
3622
3623
3624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3625   void * jresult ;
3626   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3627   ::std::type_info *result = 0 ;
3628
3629   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3630   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3631   jresult = (void *)result;
3632   return jresult;
3633 }
3634
3635
3636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3637   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3638   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3639
3640   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3641   arg2 = (Dali::Any::CloneFunc)jarg2;
3642   if (arg1) (arg1)->mCloneFunc = arg2;
3643 }
3644
3645
3646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3647   void * jresult ;
3648   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3649   Dali::Any::CloneFunc result;
3650
3651   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3652   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3653   jresult = (void *)result;
3654   return jresult;
3655 }
3656
3657
3658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3659   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3660   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3661
3662   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3663   arg2 = (Dali::Any::DeleteFunc)jarg2;
3664   if (arg1) (arg1)->mDeleteFunc = arg2;
3665 }
3666
3667
3668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3669   void * jresult ;
3670   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3671   Dali::Any::DeleteFunc result;
3672
3673   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3674   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3675   jresult = (void *)result;
3676   return jresult;
3677 }
3678
3679
3680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3681   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3682
3683   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3684   {
3685     try {
3686       delete arg1;
3687     } catch (std::out_of_range& e) {
3688       {
3689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3690       };
3691     } catch (std::exception& e) {
3692       {
3693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3694       };
3695     } catch (...) {
3696       {
3697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3698       };
3699     }
3700   }
3701 }
3702
3703
3704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
3705   Dali::Any *arg1 = (Dali::Any *) 0 ;
3706   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
3707
3708   arg1 = (Dali::Any *)jarg1;
3709   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
3710   if (arg1) (arg1)->mContainer = arg2;
3711 }
3712
3713
3714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
3715   void * jresult ;
3716   Dali::Any *arg1 = (Dali::Any *) 0 ;
3717   Dali::Any::AnyContainerBase *result = 0 ;
3718
3719   arg1 = (Dali::Any *)jarg1;
3720   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
3721   jresult = (void *)result;
3722   return jresult;
3723 }
3724
3725
3726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
3727   char *arg1 = (char *) 0 ;
3728   char *arg2 = (char *) 0 ;
3729
3730   arg1 = (char *)jarg1;
3731   arg2 = (char *)jarg2;
3732   {
3733     try {
3734       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
3735     } catch (std::out_of_range& e) {
3736       {
3737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3738       };
3739     } catch (std::exception& e) {
3740       {
3741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3742       };
3743     } catch (...) {
3744       {
3745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3746       };
3747     }
3748   }
3749 }
3750
3751
3752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
3753   void * jresult ;
3754   char *arg1 = (char *) 0 ;
3755   char *arg2 = (char *) 0 ;
3756   Dali::DaliException *result = 0 ;
3757
3758   arg1 = (char *)jarg1;
3759   arg2 = (char *)jarg2;
3760   {
3761     try {
3762       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
3763     } catch (std::out_of_range& e) {
3764       {
3765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3766       };
3767     } catch (std::exception& e) {
3768       {
3769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3770       };
3771     } catch (...) {
3772       {
3773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3774       };
3775     }
3776   }
3777   jresult = (void *)result;
3778   return jresult;
3779 }
3780
3781
3782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
3783   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3784   char *arg2 = (char *) 0 ;
3785
3786   arg1 = (Dali::DaliException *)jarg1;
3787   arg2 = (char *)jarg2;
3788   {
3789     if (arg2) {
3790       arg1->location = (char const *) (new char[strlen((const char *)arg2)+1]);
3791       strcpy((char *)arg1->location, (const char *)arg2);
3792     } else {
3793       arg1->location = 0;
3794     }
3795   }
3796 }
3797
3798
3799 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
3800   char * jresult ;
3801   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3802   char *result = 0 ;
3803
3804   arg1 = (Dali::DaliException *)jarg1;
3805   result = (char *) ((arg1)->location);
3806   jresult = SWIG_csharp_string_callback((const char *)result);
3807   return jresult;
3808 }
3809
3810
3811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
3812   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3813   char *arg2 = (char *) 0 ;
3814
3815   arg1 = (Dali::DaliException *)jarg1;
3816   arg2 = (char *)jarg2;
3817   {
3818     if (arg2) {
3819       arg1->condition = (char const *) (new char[strlen((const char *)arg2)+1]);
3820       strcpy((char *)arg1->condition, (const char *)arg2);
3821     } else {
3822       arg1->condition = 0;
3823     }
3824   }
3825 }
3826
3827
3828 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
3829   char * jresult ;
3830   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3831   char *result = 0 ;
3832
3833   arg1 = (Dali::DaliException *)jarg1;
3834   result = (char *) ((arg1)->condition);
3835   jresult = SWIG_csharp_string_callback((const char *)result);
3836   return jresult;
3837 }
3838
3839
3840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
3841   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3842
3843   arg1 = (Dali::DaliException *)jarg1;
3844   {
3845     try {
3846       delete arg1;
3847     } catch (std::out_of_range& e) {
3848       {
3849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3850       };
3851     } catch (std::exception& e) {
3852       {
3853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3854       };
3855     } catch (...) {
3856       {
3857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3858       };
3859     }
3860   }
3861 }
3862
3863
3864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
3865   void * jresult ;
3866   Dali::Vector2 *result = 0 ;
3867
3868   {
3869     try {
3870       result = (Dali::Vector2 *)new Dali::Vector2();
3871     } catch (std::out_of_range& e) {
3872       {
3873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3874       };
3875     } catch (std::exception& e) {
3876       {
3877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3878       };
3879     } catch (...) {
3880       {
3881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3882       };
3883     }
3884   }
3885   jresult = (void *)result;
3886   return jresult;
3887 }
3888
3889
3890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
3891   void * jresult ;
3892   float arg1 ;
3893   float arg2 ;
3894   Dali::Vector2 *result = 0 ;
3895
3896   arg1 = (float)jarg1;
3897   arg2 = (float)jarg2;
3898   {
3899     try {
3900       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
3901     } catch (std::out_of_range& e) {
3902       {
3903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3904       };
3905     } catch (std::exception& e) {
3906       {
3907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3908       };
3909     } catch (...) {
3910       {
3911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3912       };
3913     }
3914   }
3915   jresult = (void *)result;
3916   return jresult;
3917 }
3918
3919
3920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
3921   void * jresult ;
3922   float *arg1 = (float *) 0 ;
3923   Dali::Vector2 *result = 0 ;
3924
3925   arg1 = jarg1;
3926   {
3927     try {
3928       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
3929     } catch (std::out_of_range& e) {
3930       {
3931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3932       };
3933     } catch (std::exception& e) {
3934       {
3935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3936       };
3937     } catch (...) {
3938       {
3939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3940       };
3941     }
3942   }
3943   jresult = (void *)result;
3944
3945
3946   return jresult;
3947 }
3948
3949
3950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
3951   void * jresult ;
3952   Dali::Vector3 *arg1 = 0 ;
3953   Dali::Vector2 *result = 0 ;
3954
3955   arg1 = (Dali::Vector3 *)jarg1;
3956   if (!arg1) {
3957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3958     return 0;
3959   }
3960   {
3961     try {
3962       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
3963     } catch (std::out_of_range& e) {
3964       {
3965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3966       };
3967     } catch (std::exception& e) {
3968       {
3969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3970       };
3971     } catch (...) {
3972       {
3973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3974       };
3975     }
3976   }
3977   jresult = (void *)result;
3978   return jresult;
3979 }
3980
3981
3982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
3983   void * jresult ;
3984   Dali::Vector4 *arg1 = 0 ;
3985   Dali::Vector2 *result = 0 ;
3986
3987   arg1 = (Dali::Vector4 *)jarg1;
3988   if (!arg1) {
3989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3990     return 0;
3991   }
3992   {
3993     try {
3994       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
3995     } catch (std::out_of_range& e) {
3996       {
3997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3998       };
3999     } catch (std::exception& e) {
4000       {
4001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4002       };
4003     } catch (...) {
4004       {
4005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4006       };
4007     }
4008   }
4009   jresult = (void *)result;
4010   return jresult;
4011 }
4012
4013
4014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4015   void * jresult ;
4016   Dali::Vector2 *result = 0 ;
4017
4018   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4019   jresult = (void *)result;
4020   return jresult;
4021 }
4022
4023
4024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4025   void * jresult ;
4026   Dali::Vector2 *result = 0 ;
4027
4028   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4029   jresult = (void *)result;
4030   return jresult;
4031 }
4032
4033
4034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4035   void * jresult ;
4036   Dali::Vector2 *result = 0 ;
4037
4038   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4039   jresult = (void *)result;
4040   return jresult;
4041 }
4042
4043
4044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4045   void * jresult ;
4046   Dali::Vector2 *result = 0 ;
4047
4048   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4049   jresult = (void *)result;
4050   return jresult;
4051 }
4052
4053
4054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4055   void * jresult ;
4056   Dali::Vector2 *result = 0 ;
4057
4058   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4059   jresult = (void *)result;
4060   return jresult;
4061 }
4062
4063
4064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4065   void * jresult ;
4066   Dali::Vector2 *result = 0 ;
4067
4068   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4069   jresult = (void *)result;
4070   return jresult;
4071 }
4072
4073
4074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4075   void * jresult ;
4076   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4077   float *arg2 = (float *) 0 ;
4078   Dali::Vector2 *result = 0 ;
4079
4080   arg1 = (Dali::Vector2 *)jarg1;
4081   arg2 = jarg2;
4082   {
4083     try {
4084       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4085     } catch (std::out_of_range& e) {
4086       {
4087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4088       };
4089     } catch (std::exception& e) {
4090       {
4091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4092       };
4093     } catch (...) {
4094       {
4095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4096       };
4097     }
4098   }
4099   jresult = (void *)result;
4100
4101
4102   return jresult;
4103 }
4104
4105
4106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4107   void * jresult ;
4108   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4109   Dali::Vector3 *arg2 = 0 ;
4110   Dali::Vector2 *result = 0 ;
4111
4112   arg1 = (Dali::Vector2 *)jarg1;
4113   arg2 = (Dali::Vector3 *)jarg2;
4114   if (!arg2) {
4115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4116     return 0;
4117   }
4118   {
4119     try {
4120       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4121     } catch (std::out_of_range& e) {
4122       {
4123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4124       };
4125     } catch (std::exception& e) {
4126       {
4127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4128       };
4129     } catch (...) {
4130       {
4131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4132       };
4133     }
4134   }
4135   jresult = (void *)result;
4136   return jresult;
4137 }
4138
4139
4140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4141   void * jresult ;
4142   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4143   Dali::Vector4 *arg2 = 0 ;
4144   Dali::Vector2 *result = 0 ;
4145
4146   arg1 = (Dali::Vector2 *)jarg1;
4147   arg2 = (Dali::Vector4 *)jarg2;
4148   if (!arg2) {
4149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4150     return 0;
4151   }
4152   {
4153     try {
4154       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4155     } catch (std::out_of_range& e) {
4156       {
4157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4158       };
4159     } catch (std::exception& e) {
4160       {
4161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4162       };
4163     } catch (...) {
4164       {
4165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4166       };
4167     }
4168   }
4169   jresult = (void *)result;
4170   return jresult;
4171 }
4172
4173
4174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4175   void * jresult ;
4176   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4177   Dali::Vector2 *arg2 = 0 ;
4178   Dali::Vector2 result;
4179
4180   arg1 = (Dali::Vector2 *)jarg1;
4181   arg2 = (Dali::Vector2 *)jarg2;
4182   if (!arg2) {
4183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4184     return 0;
4185   }
4186   {
4187     try {
4188       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4189     } catch (std::out_of_range& e) {
4190       {
4191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4192       };
4193     } catch (std::exception& e) {
4194       {
4195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4196       };
4197     } catch (...) {
4198       {
4199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4200       };
4201     }
4202   }
4203   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4204   return jresult;
4205 }
4206
4207
4208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4209   void * jresult ;
4210   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4211   Dali::Vector2 *arg2 = 0 ;
4212   Dali::Vector2 *result = 0 ;
4213
4214   arg1 = (Dali::Vector2 *)jarg1;
4215   arg2 = (Dali::Vector2 *)jarg2;
4216   if (!arg2) {
4217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4218     return 0;
4219   }
4220   {
4221     try {
4222       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4223     } catch (std::out_of_range& e) {
4224       {
4225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4226       };
4227     } catch (std::exception& e) {
4228       {
4229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4230       };
4231     } catch (...) {
4232       {
4233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4234       };
4235     }
4236   }
4237   jresult = (void *)result;
4238   return jresult;
4239 }
4240
4241
4242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4243   void * jresult ;
4244   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4245   Dali::Vector2 *arg2 = 0 ;
4246   Dali::Vector2 result;
4247
4248   arg1 = (Dali::Vector2 *)jarg1;
4249   arg2 = (Dali::Vector2 *)jarg2;
4250   if (!arg2) {
4251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4252     return 0;
4253   }
4254   {
4255     try {
4256       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4257     } catch (std::out_of_range& e) {
4258       {
4259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4260       };
4261     } catch (std::exception& e) {
4262       {
4263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4264       };
4265     } catch (...) {
4266       {
4267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4268       };
4269     }
4270   }
4271   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4272   return jresult;
4273 }
4274
4275
4276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4277   void * jresult ;
4278   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4279   Dali::Vector2 *arg2 = 0 ;
4280   Dali::Vector2 *result = 0 ;
4281
4282   arg1 = (Dali::Vector2 *)jarg1;
4283   arg2 = (Dali::Vector2 *)jarg2;
4284   if (!arg2) {
4285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4286     return 0;
4287   }
4288   {
4289     try {
4290       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4291     } catch (std::out_of_range& e) {
4292       {
4293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4294       };
4295     } catch (std::exception& e) {
4296       {
4297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4298       };
4299     } catch (...) {
4300       {
4301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4302       };
4303     }
4304   }
4305   jresult = (void *)result;
4306   return jresult;
4307 }
4308
4309
4310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4311   void * jresult ;
4312   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4313   Dali::Vector2 *arg2 = 0 ;
4314   Dali::Vector2 result;
4315
4316   arg1 = (Dali::Vector2 *)jarg1;
4317   arg2 = (Dali::Vector2 *)jarg2;
4318   if (!arg2) {
4319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4320     return 0;
4321   }
4322   {
4323     try {
4324       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4325     } catch (std::out_of_range& e) {
4326       {
4327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4328       };
4329     } catch (std::exception& e) {
4330       {
4331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4332       };
4333     } catch (...) {
4334       {
4335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4336       };
4337     }
4338   }
4339   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4340   return jresult;
4341 }
4342
4343
4344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4345   void * jresult ;
4346   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4347   float arg2 ;
4348   Dali::Vector2 result;
4349
4350   arg1 = (Dali::Vector2 *)jarg1;
4351   arg2 = (float)jarg2;
4352   {
4353     try {
4354       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4355     } catch (std::out_of_range& e) {
4356       {
4357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4358       };
4359     } catch (std::exception& e) {
4360       {
4361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4362       };
4363     } catch (...) {
4364       {
4365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4366       };
4367     }
4368   }
4369   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4370   return jresult;
4371 }
4372
4373
4374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4375   void * jresult ;
4376   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4377   Dali::Vector2 *arg2 = 0 ;
4378   Dali::Vector2 *result = 0 ;
4379
4380   arg1 = (Dali::Vector2 *)jarg1;
4381   arg2 = (Dali::Vector2 *)jarg2;
4382   if (!arg2) {
4383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4384     return 0;
4385   }
4386   {
4387     try {
4388       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4389     } catch (std::out_of_range& e) {
4390       {
4391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4392       };
4393     } catch (std::exception& e) {
4394       {
4395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4396       };
4397     } catch (...) {
4398       {
4399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4400       };
4401     }
4402   }
4403   jresult = (void *)result;
4404   return jresult;
4405 }
4406
4407
4408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4409   void * jresult ;
4410   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4411   float arg2 ;
4412   Dali::Vector2 *result = 0 ;
4413
4414   arg1 = (Dali::Vector2 *)jarg1;
4415   arg2 = (float)jarg2;
4416   {
4417     try {
4418       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4419     } catch (std::out_of_range& e) {
4420       {
4421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4422       };
4423     } catch (std::exception& e) {
4424       {
4425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4426       };
4427     } catch (...) {
4428       {
4429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4430       };
4431     }
4432   }
4433   jresult = (void *)result;
4434   return jresult;
4435 }
4436
4437
4438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4439   void * jresult ;
4440   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4441   Dali::Vector2 *arg2 = 0 ;
4442   Dali::Vector2 result;
4443
4444   arg1 = (Dali::Vector2 *)jarg1;
4445   arg2 = (Dali::Vector2 *)jarg2;
4446   if (!arg2) {
4447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4448     return 0;
4449   }
4450   {
4451     try {
4452       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4453     } catch (std::out_of_range& e) {
4454       {
4455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4456       };
4457     } catch (std::exception& e) {
4458       {
4459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4460       };
4461     } catch (...) {
4462       {
4463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4464       };
4465     }
4466   }
4467   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4468   return jresult;
4469 }
4470
4471
4472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4473   void * jresult ;
4474   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4475   float arg2 ;
4476   Dali::Vector2 result;
4477
4478   arg1 = (Dali::Vector2 *)jarg1;
4479   arg2 = (float)jarg2;
4480   {
4481     try {
4482       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4483     } catch (std::out_of_range& e) {
4484       {
4485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4486       };
4487     } catch (std::exception& e) {
4488       {
4489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4490       };
4491     } catch (...) {
4492       {
4493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4494       };
4495     }
4496   }
4497   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4498   return jresult;
4499 }
4500
4501
4502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4503   void * jresult ;
4504   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4505   Dali::Vector2 *arg2 = 0 ;
4506   Dali::Vector2 *result = 0 ;
4507
4508   arg1 = (Dali::Vector2 *)jarg1;
4509   arg2 = (Dali::Vector2 *)jarg2;
4510   if (!arg2) {
4511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4512     return 0;
4513   }
4514   {
4515     try {
4516       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4517     } catch (std::out_of_range& e) {
4518       {
4519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4520       };
4521     } catch (std::exception& e) {
4522       {
4523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4524       };
4525     } catch (...) {
4526       {
4527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4528       };
4529     }
4530   }
4531   jresult = (void *)result;
4532   return jresult;
4533 }
4534
4535
4536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4537   void * jresult ;
4538   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4539   float arg2 ;
4540   Dali::Vector2 *result = 0 ;
4541
4542   arg1 = (Dali::Vector2 *)jarg1;
4543   arg2 = (float)jarg2;
4544   {
4545     try {
4546       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4547     } catch (std::out_of_range& e) {
4548       {
4549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4550       };
4551     } catch (std::exception& e) {
4552       {
4553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4554       };
4555     } catch (...) {
4556       {
4557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4558       };
4559     }
4560   }
4561   jresult = (void *)result;
4562   return jresult;
4563 }
4564
4565
4566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
4567   void * jresult ;
4568   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4569   Dali::Vector2 result;
4570
4571   arg1 = (Dali::Vector2 *)jarg1;
4572   {
4573     try {
4574       result = ((Dali::Vector2 const *)arg1)->operator -();
4575     } catch (std::out_of_range& e) {
4576       {
4577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4578       };
4579     } catch (std::exception& e) {
4580       {
4581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4582       };
4583     } catch (...) {
4584       {
4585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4586       };
4587     }
4588   }
4589   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4590   return jresult;
4591 }
4592
4593
4594 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
4595   unsigned int jresult ;
4596   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4597   Dali::Vector2 *arg2 = 0 ;
4598   bool result;
4599
4600   arg1 = (Dali::Vector2 *)jarg1;
4601   arg2 = (Dali::Vector2 *)jarg2;
4602   if (!arg2) {
4603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4604     return 0;
4605   }
4606   {
4607     try {
4608       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
4609     } catch (std::out_of_range& e) {
4610       {
4611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4612       };
4613     } catch (std::exception& e) {
4614       {
4615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4616       };
4617     } catch (...) {
4618       {
4619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4620       };
4621     }
4622   }
4623   jresult = result;
4624   return jresult;
4625 }
4626
4627
4628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
4629   unsigned int jresult ;
4630   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4631   Dali::Vector2 *arg2 = 0 ;
4632   bool result;
4633
4634   arg1 = (Dali::Vector2 *)jarg1;
4635   arg2 = (Dali::Vector2 *)jarg2;
4636   if (!arg2) {
4637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4638     return 0;
4639   }
4640   {
4641     try {
4642       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
4643     } catch (std::out_of_range& e) {
4644       {
4645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4646       };
4647     } catch (std::exception& e) {
4648       {
4649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4650       };
4651     } catch (...) {
4652       {
4653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4654       };
4655     }
4656   }
4657   jresult = result;
4658   return jresult;
4659 }
4660
4661
4662 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4663   float jresult ;
4664   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4665   unsigned int arg2 ;
4666   float *result = 0 ;
4667
4668   arg1 = (Dali::Vector2 *)jarg1;
4669   arg2 = (unsigned int)jarg2;
4670   {
4671     try {
4672       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
4673     } catch (std::out_of_range& e) {
4674       {
4675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4676       };
4677     } catch (std::exception& e) {
4678       {
4679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4680       };
4681     } catch (...) {
4682       {
4683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4684       };
4685     }
4686   }
4687   jresult = *result;
4688   return jresult;
4689 }
4690
4691
4692 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
4693   float jresult ;
4694   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4695   float result;
4696
4697   arg1 = (Dali::Vector2 *)jarg1;
4698   {
4699     try {
4700       result = (float)((Dali::Vector2 const *)arg1)->Length();
4701     } catch (std::out_of_range& e) {
4702       {
4703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4704       };
4705     } catch (std::exception& e) {
4706       {
4707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4708       };
4709     } catch (...) {
4710       {
4711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4712       };
4713     }
4714   }
4715   jresult = result;
4716   return jresult;
4717 }
4718
4719
4720 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
4721   float jresult ;
4722   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4723   float result;
4724
4725   arg1 = (Dali::Vector2 *)jarg1;
4726   {
4727     try {
4728       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
4729     } catch (std::out_of_range& e) {
4730       {
4731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4732       };
4733     } catch (std::exception& e) {
4734       {
4735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4736       };
4737     } catch (...) {
4738       {
4739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4740       };
4741     }
4742   }
4743   jresult = result;
4744   return jresult;
4745 }
4746
4747
4748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
4749   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4750
4751   arg1 = (Dali::Vector2 *)jarg1;
4752   {
4753     try {
4754       (arg1)->Normalize();
4755     } catch (std::out_of_range& e) {
4756       {
4757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4758       };
4759     } catch (std::exception& e) {
4760       {
4761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4762       };
4763     } catch (...) {
4764       {
4765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4766       };
4767     }
4768   }
4769 }
4770
4771
4772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4773   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4774   Dali::Vector2 *arg2 = 0 ;
4775   Dali::Vector2 *arg3 = 0 ;
4776
4777   arg1 = (Dali::Vector2 *)jarg1;
4778   arg2 = (Dali::Vector2 *)jarg2;
4779   if (!arg2) {
4780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4781     return ;
4782   }
4783   arg3 = (Dali::Vector2 *)jarg3;
4784   if (!arg3) {
4785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4786     return ;
4787   }
4788   {
4789     try {
4790       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
4791     } catch (std::out_of_range& e) {
4792       {
4793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4794       };
4795     } catch (std::exception& e) {
4796       {
4797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4798       };
4799     } catch (...) {
4800       {
4801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4802       };
4803     }
4804   }
4805 }
4806
4807
4808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
4809   void * jresult ;
4810   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4811   float *result = 0 ;
4812
4813   arg1 = (Dali::Vector2 *)jarg1;
4814   {
4815     try {
4816       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
4817     } catch (std::out_of_range& e) {
4818       {
4819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4820       };
4821     } catch (std::exception& e) {
4822       {
4823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4824       };
4825     } catch (...) {
4826       {
4827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4828       };
4829     }
4830   }
4831   jresult = (void *)result;
4832   return jresult;
4833 }
4834
4835
4836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
4837   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4838   float arg2 ;
4839
4840   arg1 = (Dali::Vector2 *)jarg1;
4841   arg2 = (float)jarg2;
4842   if (arg1) (arg1)->x = arg2;
4843 }
4844
4845
4846 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
4847   float jresult ;
4848   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4849   float result;
4850
4851   arg1 = (Dali::Vector2 *)jarg1;
4852   result = (float) ((arg1)->x);
4853   jresult = result;
4854   return jresult;
4855 }
4856
4857
4858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
4859   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4860   float arg2 ;
4861
4862   arg1 = (Dali::Vector2 *)jarg1;
4863   arg2 = (float)jarg2;
4864   if (arg1) (arg1)->width = arg2;
4865 }
4866
4867
4868 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
4869   float jresult ;
4870   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4871   float result;
4872
4873   arg1 = (Dali::Vector2 *)jarg1;
4874   result = (float) ((arg1)->width);
4875   jresult = result;
4876   return jresult;
4877 }
4878
4879
4880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
4881   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4882   float arg2 ;
4883
4884   arg1 = (Dali::Vector2 *)jarg1;
4885   arg2 = (float)jarg2;
4886   if (arg1) (arg1)->y = arg2;
4887 }
4888
4889
4890 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
4891   float jresult ;
4892   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4893   float result;
4894
4895   arg1 = (Dali::Vector2 *)jarg1;
4896   result = (float) ((arg1)->y);
4897   jresult = result;
4898   return jresult;
4899 }
4900
4901
4902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
4903   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4904   float arg2 ;
4905
4906   arg1 = (Dali::Vector2 *)jarg1;
4907   arg2 = (float)jarg2;
4908   if (arg1) (arg1)->height = arg2;
4909 }
4910
4911
4912 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
4913   float jresult ;
4914   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4915   float result;
4916
4917   arg1 = (Dali::Vector2 *)jarg1;
4918   result = (float) ((arg1)->height);
4919   jresult = result;
4920   return jresult;
4921 }
4922
4923
4924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
4925   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4926
4927   arg1 = (Dali::Vector2 *)jarg1;
4928   {
4929     try {
4930       delete arg1;
4931     } catch (std::out_of_range& e) {
4932       {
4933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4934       };
4935     } catch (std::exception& e) {
4936       {
4937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4938       };
4939     } catch (...) {
4940       {
4941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4942       };
4943     }
4944   }
4945 }
4946
4947
4948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
4949   void * jresult ;
4950   Dali::Vector2 *arg1 = 0 ;
4951   Dali::Vector2 *arg2 = 0 ;
4952   Dali::Vector2 result;
4953
4954   arg1 = (Dali::Vector2 *)jarg1;
4955   if (!arg1) {
4956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4957     return 0;
4958   }
4959   arg2 = (Dali::Vector2 *)jarg2;
4960   if (!arg2) {
4961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4962     return 0;
4963   }
4964   {
4965     try {
4966       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4967     } catch (std::out_of_range& e) {
4968       {
4969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4970       };
4971     } catch (std::exception& e) {
4972       {
4973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4974       };
4975     } catch (...) {
4976       {
4977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4978       };
4979     }
4980   }
4981   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4982   return jresult;
4983 }
4984
4985
4986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
4987   void * jresult ;
4988   Dali::Vector2 *arg1 = 0 ;
4989   Dali::Vector2 *arg2 = 0 ;
4990   Dali::Vector2 result;
4991
4992   arg1 = (Dali::Vector2 *)jarg1;
4993   if (!arg1) {
4994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4995     return 0;
4996   }
4997   arg2 = (Dali::Vector2 *)jarg2;
4998   if (!arg2) {
4999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5000     return 0;
5001   }
5002   {
5003     try {
5004       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5005     } catch (std::out_of_range& e) {
5006       {
5007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5008       };
5009     } catch (std::exception& e) {
5010       {
5011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5012       };
5013     } catch (...) {
5014       {
5015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5016       };
5017     }
5018   }
5019   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5020   return jresult;
5021 }
5022
5023
5024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5025   void * jresult ;
5026   Dali::Vector2 *arg1 = 0 ;
5027   float *arg2 = 0 ;
5028   float *arg3 = 0 ;
5029   float temp2 ;
5030   float temp3 ;
5031   Dali::Vector2 result;
5032
5033   arg1 = (Dali::Vector2 *)jarg1;
5034   if (!arg1) {
5035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5036     return 0;
5037   }
5038   temp2 = (float)jarg2;
5039   arg2 = &temp2;
5040   temp3 = (float)jarg3;
5041   arg3 = &temp3;
5042   {
5043     try {
5044       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5045     } catch (std::out_of_range& e) {
5046       {
5047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5048       };
5049     } catch (std::exception& e) {
5050       {
5051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5052       };
5053     } catch (...) {
5054       {
5055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5056       };
5057     }
5058   }
5059   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5060   return jresult;
5061 }
5062
5063
5064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5065   void * jresult ;
5066   Dali::Vector3 *result = 0 ;
5067
5068   {
5069     try {
5070       result = (Dali::Vector3 *)new Dali::Vector3();
5071     } catch (std::out_of_range& e) {
5072       {
5073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5074       };
5075     } catch (std::exception& e) {
5076       {
5077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5078       };
5079     } catch (...) {
5080       {
5081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5082       };
5083     }
5084   }
5085   jresult = (void *)result;
5086   return jresult;
5087 }
5088
5089
5090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5091   void * jresult ;
5092   float arg1 ;
5093   float arg2 ;
5094   float arg3 ;
5095   Dali::Vector3 *result = 0 ;
5096
5097   arg1 = (float)jarg1;
5098   arg2 = (float)jarg2;
5099   arg3 = (float)jarg3;
5100   {
5101     try {
5102       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5103     } catch (std::out_of_range& e) {
5104       {
5105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5106       };
5107     } catch (std::exception& e) {
5108       {
5109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5110       };
5111     } catch (...) {
5112       {
5113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5114       };
5115     }
5116   }
5117   jresult = (void *)result;
5118   return jresult;
5119 }
5120
5121
5122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5123   void * jresult ;
5124   float *arg1 = (float *) 0 ;
5125   Dali::Vector3 *result = 0 ;
5126
5127   arg1 = jarg1;
5128   {
5129     try {
5130       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5131     } catch (std::out_of_range& e) {
5132       {
5133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5134       };
5135     } catch (std::exception& e) {
5136       {
5137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5138       };
5139     } catch (...) {
5140       {
5141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5142       };
5143     }
5144   }
5145   jresult = (void *)result;
5146
5147
5148   return jresult;
5149 }
5150
5151
5152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5153   void * jresult ;
5154   Dali::Vector2 *arg1 = 0 ;
5155   Dali::Vector3 *result = 0 ;
5156
5157   arg1 = (Dali::Vector2 *)jarg1;
5158   if (!arg1) {
5159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5160     return 0;
5161   }
5162   {
5163     try {
5164       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5165     } catch (std::out_of_range& e) {
5166       {
5167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5168       };
5169     } catch (std::exception& e) {
5170       {
5171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5172       };
5173     } catch (...) {
5174       {
5175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5176       };
5177     }
5178   }
5179   jresult = (void *)result;
5180   return jresult;
5181 }
5182
5183
5184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5185   void * jresult ;
5186   Dali::Vector4 *arg1 = 0 ;
5187   Dali::Vector3 *result = 0 ;
5188
5189   arg1 = (Dali::Vector4 *)jarg1;
5190   if (!arg1) {
5191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5192     return 0;
5193   }
5194   {
5195     try {
5196       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5197     } catch (std::out_of_range& e) {
5198       {
5199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5200       };
5201     } catch (std::exception& e) {
5202       {
5203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5204       };
5205     } catch (...) {
5206       {
5207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5208       };
5209     }
5210   }
5211   jresult = (void *)result;
5212   return jresult;
5213 }
5214
5215
5216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5217   void * jresult ;
5218   Dali::Vector3 *result = 0 ;
5219
5220   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5221   jresult = (void *)result;
5222   return jresult;
5223 }
5224
5225
5226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5227   void * jresult ;
5228   Dali::Vector3 *result = 0 ;
5229
5230   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5231   jresult = (void *)result;
5232   return jresult;
5233 }
5234
5235
5236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5237   void * jresult ;
5238   Dali::Vector3 *result = 0 ;
5239
5240   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5241   jresult = (void *)result;
5242   return jresult;
5243 }
5244
5245
5246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5247   void * jresult ;
5248   Dali::Vector3 *result = 0 ;
5249
5250   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5251   jresult = (void *)result;
5252   return jresult;
5253 }
5254
5255
5256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5257   void * jresult ;
5258   Dali::Vector3 *result = 0 ;
5259
5260   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5261   jresult = (void *)result;
5262   return jresult;
5263 }
5264
5265
5266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5267   void * jresult ;
5268   Dali::Vector3 *result = 0 ;
5269
5270   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5271   jresult = (void *)result;
5272   return jresult;
5273 }
5274
5275
5276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5277   void * jresult ;
5278   Dali::Vector3 *result = 0 ;
5279
5280   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5281   jresult = (void *)result;
5282   return jresult;
5283 }
5284
5285
5286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5287   void * jresult ;
5288   Dali::Vector3 *result = 0 ;
5289
5290   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5291   jresult = (void *)result;
5292   return jresult;
5293 }
5294
5295
5296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5297   void * jresult ;
5298   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5299   float *arg2 = (float *) 0 ;
5300   Dali::Vector3 *result = 0 ;
5301
5302   arg1 = (Dali::Vector3 *)jarg1;
5303   arg2 = jarg2;
5304   {
5305     try {
5306       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5307     } catch (std::out_of_range& e) {
5308       {
5309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5310       };
5311     } catch (std::exception& e) {
5312       {
5313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5314       };
5315     } catch (...) {
5316       {
5317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5318       };
5319     }
5320   }
5321   jresult = (void *)result;
5322
5323
5324   return jresult;
5325 }
5326
5327
5328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5329   void * jresult ;
5330   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5331   Dali::Vector2 *arg2 = 0 ;
5332   Dali::Vector3 *result = 0 ;
5333
5334   arg1 = (Dali::Vector3 *)jarg1;
5335   arg2 = (Dali::Vector2 *)jarg2;
5336   if (!arg2) {
5337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5338     return 0;
5339   }
5340   {
5341     try {
5342       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5343     } catch (std::out_of_range& e) {
5344       {
5345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5346       };
5347     } catch (std::exception& e) {
5348       {
5349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5350       };
5351     } catch (...) {
5352       {
5353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5354       };
5355     }
5356   }
5357   jresult = (void *)result;
5358   return jresult;
5359 }
5360
5361
5362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5363   void * jresult ;
5364   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5365   Dali::Vector4 *arg2 = 0 ;
5366   Dali::Vector3 *result = 0 ;
5367
5368   arg1 = (Dali::Vector3 *)jarg1;
5369   arg2 = (Dali::Vector4 *)jarg2;
5370   if (!arg2) {
5371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5372     return 0;
5373   }
5374   {
5375     try {
5376       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5377     } catch (std::out_of_range& e) {
5378       {
5379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5380       };
5381     } catch (std::exception& e) {
5382       {
5383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5384       };
5385     } catch (...) {
5386       {
5387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5388       };
5389     }
5390   }
5391   jresult = (void *)result;
5392   return jresult;
5393 }
5394
5395
5396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5397   void * jresult ;
5398   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5399   Dali::Vector3 *arg2 = 0 ;
5400   Dali::Vector3 result;
5401
5402   arg1 = (Dali::Vector3 *)jarg1;
5403   arg2 = (Dali::Vector3 *)jarg2;
5404   if (!arg2) {
5405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5406     return 0;
5407   }
5408   {
5409     try {
5410       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5411     } catch (std::out_of_range& e) {
5412       {
5413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5414       };
5415     } catch (std::exception& e) {
5416       {
5417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5418       };
5419     } catch (...) {
5420       {
5421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5422       };
5423     }
5424   }
5425   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5426   return jresult;
5427 }
5428
5429
5430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5431   void * jresult ;
5432   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5433   Dali::Vector3 *arg2 = 0 ;
5434   Dali::Vector3 *result = 0 ;
5435
5436   arg1 = (Dali::Vector3 *)jarg1;
5437   arg2 = (Dali::Vector3 *)jarg2;
5438   if (!arg2) {
5439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5440     return 0;
5441   }
5442   {
5443     try {
5444       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5445     } catch (std::out_of_range& e) {
5446       {
5447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5448       };
5449     } catch (std::exception& e) {
5450       {
5451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5452       };
5453     } catch (...) {
5454       {
5455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5456       };
5457     }
5458   }
5459   jresult = (void *)result;
5460   return jresult;
5461 }
5462
5463
5464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5465   void * jresult ;
5466   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5467   Dali::Vector3 *arg2 = 0 ;
5468   Dali::Vector3 result;
5469
5470   arg1 = (Dali::Vector3 *)jarg1;
5471   arg2 = (Dali::Vector3 *)jarg2;
5472   if (!arg2) {
5473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5474     return 0;
5475   }
5476   {
5477     try {
5478       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
5479     } catch (std::out_of_range& e) {
5480       {
5481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5482       };
5483     } catch (std::exception& e) {
5484       {
5485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5486       };
5487     } catch (...) {
5488       {
5489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5490       };
5491     }
5492   }
5493   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5494   return jresult;
5495 }
5496
5497
5498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
5499   void * jresult ;
5500   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5501   Dali::Vector3 *arg2 = 0 ;
5502   Dali::Vector3 *result = 0 ;
5503
5504   arg1 = (Dali::Vector3 *)jarg1;
5505   arg2 = (Dali::Vector3 *)jarg2;
5506   if (!arg2) {
5507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5508     return 0;
5509   }
5510   {
5511     try {
5512       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
5513     } catch (std::out_of_range& e) {
5514       {
5515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5516       };
5517     } catch (std::exception& e) {
5518       {
5519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5520       };
5521     } catch (...) {
5522       {
5523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5524       };
5525     }
5526   }
5527   jresult = (void *)result;
5528   return jresult;
5529 }
5530
5531
5532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5533   void * jresult ;
5534   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5535   Dali::Vector3 *arg2 = 0 ;
5536   Dali::Vector3 result;
5537
5538   arg1 = (Dali::Vector3 *)jarg1;
5539   arg2 = (Dali::Vector3 *)jarg2;
5540   if (!arg2) {
5541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5542     return 0;
5543   }
5544   {
5545     try {
5546       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
5547     } catch (std::out_of_range& e) {
5548       {
5549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5550       };
5551     } catch (std::exception& e) {
5552       {
5553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5554       };
5555     } catch (...) {
5556       {
5557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5558       };
5559     }
5560   }
5561   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5562   return jresult;
5563 }
5564
5565
5566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
5567   void * jresult ;
5568   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5569   float arg2 ;
5570   Dali::Vector3 result;
5571
5572   arg1 = (Dali::Vector3 *)jarg1;
5573   arg2 = (float)jarg2;
5574   {
5575     try {
5576       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
5577     } catch (std::out_of_range& e) {
5578       {
5579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5580       };
5581     } catch (std::exception& e) {
5582       {
5583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5584       };
5585     } catch (...) {
5586       {
5587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5588       };
5589     }
5590   }
5591   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5592   return jresult;
5593 }
5594
5595
5596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
5597   void * jresult ;
5598   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5599   Dali::Vector3 *arg2 = 0 ;
5600   Dali::Vector3 *result = 0 ;
5601
5602   arg1 = (Dali::Vector3 *)jarg1;
5603   arg2 = (Dali::Vector3 *)jarg2;
5604   if (!arg2) {
5605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5606     return 0;
5607   }
5608   {
5609     try {
5610       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
5611     } catch (std::out_of_range& e) {
5612       {
5613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5614       };
5615     } catch (std::exception& e) {
5616       {
5617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5618       };
5619     } catch (...) {
5620       {
5621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5622       };
5623     }
5624   }
5625   jresult = (void *)result;
5626   return jresult;
5627 }
5628
5629
5630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
5631   void * jresult ;
5632   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5633   float arg2 ;
5634   Dali::Vector3 *result = 0 ;
5635
5636   arg1 = (Dali::Vector3 *)jarg1;
5637   arg2 = (float)jarg2;
5638   {
5639     try {
5640       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
5641     } catch (std::out_of_range& e) {
5642       {
5643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5644       };
5645     } catch (std::exception& e) {
5646       {
5647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5648       };
5649     } catch (...) {
5650       {
5651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5652       };
5653     }
5654   }
5655   jresult = (void *)result;
5656   return jresult;
5657 }
5658
5659
5660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
5661   void * jresult ;
5662   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5663   Dali::Quaternion *arg2 = 0 ;
5664   Dali::Vector3 *result = 0 ;
5665
5666   arg1 = (Dali::Vector3 *)jarg1;
5667   arg2 = (Dali::Quaternion *)jarg2;
5668   if (!arg2) {
5669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
5670     return 0;
5671   }
5672   {
5673     try {
5674       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
5675     } catch (std::out_of_range& e) {
5676       {
5677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5678       };
5679     } catch (std::exception& e) {
5680       {
5681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5682       };
5683     } catch (...) {
5684       {
5685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5686       };
5687     }
5688   }
5689   jresult = (void *)result;
5690   return jresult;
5691 }
5692
5693
5694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
5695   void * jresult ;
5696   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5697   Dali::Vector3 *arg2 = 0 ;
5698   Dali::Vector3 result;
5699
5700   arg1 = (Dali::Vector3 *)jarg1;
5701   arg2 = (Dali::Vector3 *)jarg2;
5702   if (!arg2) {
5703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5704     return 0;
5705   }
5706   {
5707     try {
5708       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
5709     } catch (std::out_of_range& e) {
5710       {
5711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5712       };
5713     } catch (std::exception& e) {
5714       {
5715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5716       };
5717     } catch (...) {
5718       {
5719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5720       };
5721     }
5722   }
5723   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5724   return jresult;
5725 }
5726
5727
5728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
5729   void * jresult ;
5730   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5731   float arg2 ;
5732   Dali::Vector3 result;
5733
5734   arg1 = (Dali::Vector3 *)jarg1;
5735   arg2 = (float)jarg2;
5736   {
5737     try {
5738       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
5739     } catch (std::out_of_range& e) {
5740       {
5741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5742       };
5743     } catch (std::exception& e) {
5744       {
5745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5746       };
5747     } catch (...) {
5748       {
5749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5750       };
5751     }
5752   }
5753   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5754   return jresult;
5755 }
5756
5757
5758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
5759   void * jresult ;
5760   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5761   Dali::Vector3 *arg2 = 0 ;
5762   Dali::Vector3 *result = 0 ;
5763
5764   arg1 = (Dali::Vector3 *)jarg1;
5765   arg2 = (Dali::Vector3 *)jarg2;
5766   if (!arg2) {
5767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5768     return 0;
5769   }
5770   {
5771     try {
5772       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
5773     } catch (std::out_of_range& e) {
5774       {
5775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5776       };
5777     } catch (std::exception& e) {
5778       {
5779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5780       };
5781     } catch (...) {
5782       {
5783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5784       };
5785     }
5786   }
5787   jresult = (void *)result;
5788   return jresult;
5789 }
5790
5791
5792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
5793   void * jresult ;
5794   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5795   float arg2 ;
5796   Dali::Vector3 *result = 0 ;
5797
5798   arg1 = (Dali::Vector3 *)jarg1;
5799   arg2 = (float)jarg2;
5800   {
5801     try {
5802       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
5803     } catch (std::out_of_range& e) {
5804       {
5805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5806       };
5807     } catch (std::exception& e) {
5808       {
5809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5810       };
5811     } catch (...) {
5812       {
5813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5814       };
5815     }
5816   }
5817   jresult = (void *)result;
5818   return jresult;
5819 }
5820
5821
5822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
5823   void * jresult ;
5824   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5825   Dali::Vector3 result;
5826
5827   arg1 = (Dali::Vector3 *)jarg1;
5828   {
5829     try {
5830       result = ((Dali::Vector3 const *)arg1)->operator -();
5831     } catch (std::out_of_range& e) {
5832       {
5833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5834       };
5835     } catch (std::exception& e) {
5836       {
5837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5838       };
5839     } catch (...) {
5840       {
5841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5842       };
5843     }
5844   }
5845   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5846   return jresult;
5847 }
5848
5849
5850 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
5851   unsigned int jresult ;
5852   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5853   Dali::Vector3 *arg2 = 0 ;
5854   bool result;
5855
5856   arg1 = (Dali::Vector3 *)jarg1;
5857   arg2 = (Dali::Vector3 *)jarg2;
5858   if (!arg2) {
5859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5860     return 0;
5861   }
5862   {
5863     try {
5864       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
5865     } catch (std::out_of_range& e) {
5866       {
5867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5868       };
5869     } catch (std::exception& e) {
5870       {
5871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5872       };
5873     } catch (...) {
5874       {
5875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5876       };
5877     }
5878   }
5879   jresult = result;
5880   return jresult;
5881 }
5882
5883
5884 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
5885   unsigned int jresult ;
5886   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5887   Dali::Vector3 *arg2 = 0 ;
5888   bool result;
5889
5890   arg1 = (Dali::Vector3 *)jarg1;
5891   arg2 = (Dali::Vector3 *)jarg2;
5892   if (!arg2) {
5893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5894     return 0;
5895   }
5896   {
5897     try {
5898       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
5899     } catch (std::out_of_range& e) {
5900       {
5901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5902       };
5903     } catch (std::exception& e) {
5904       {
5905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5906       };
5907     } catch (...) {
5908       {
5909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5910       };
5911     }
5912   }
5913   jresult = result;
5914   return jresult;
5915 }
5916
5917
5918 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5919   float jresult ;
5920   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5921   unsigned int arg2 ;
5922   float *result = 0 ;
5923
5924   arg1 = (Dali::Vector3 *)jarg1;
5925   arg2 = (unsigned int)jarg2;
5926   {
5927     try {
5928       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
5929     } catch (std::out_of_range& e) {
5930       {
5931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5932       };
5933     } catch (std::exception& e) {
5934       {
5935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5936       };
5937     } catch (...) {
5938       {
5939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5940       };
5941     }
5942   }
5943   jresult = *result;
5944   return jresult;
5945 }
5946
5947
5948 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
5949   float jresult ;
5950   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5951   Dali::Vector3 *arg2 = 0 ;
5952   float result;
5953
5954   arg1 = (Dali::Vector3 *)jarg1;
5955   arg2 = (Dali::Vector3 *)jarg2;
5956   if (!arg2) {
5957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5958     return 0;
5959   }
5960   {
5961     try {
5962       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
5963     } catch (std::out_of_range& e) {
5964       {
5965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5966       };
5967     } catch (std::exception& e) {
5968       {
5969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5970       };
5971     } catch (...) {
5972       {
5973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5974       };
5975     }
5976   }
5977   jresult = result;
5978   return jresult;
5979 }
5980
5981
5982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
5983   void * jresult ;
5984   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5985   Dali::Vector3 *arg2 = 0 ;
5986   Dali::Vector3 result;
5987
5988   arg1 = (Dali::Vector3 *)jarg1;
5989   arg2 = (Dali::Vector3 *)jarg2;
5990   if (!arg2) {
5991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5992     return 0;
5993   }
5994   {
5995     try {
5996       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
5997     } catch (std::out_of_range& e) {
5998       {
5999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6000       };
6001     } catch (std::exception& e) {
6002       {
6003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6004       };
6005     } catch (...) {
6006       {
6007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6008       };
6009     }
6010   }
6011   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6012   return jresult;
6013 }
6014
6015
6016 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6017   float jresult ;
6018   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6019   float result;
6020
6021   arg1 = (Dali::Vector3 *)jarg1;
6022   {
6023     try {
6024       result = (float)((Dali::Vector3 const *)arg1)->Length();
6025     } catch (std::out_of_range& e) {
6026       {
6027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6028       };
6029     } catch (std::exception& e) {
6030       {
6031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6032       };
6033     } catch (...) {
6034       {
6035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6036       };
6037     }
6038   }
6039   jresult = result;
6040   return jresult;
6041 }
6042
6043
6044 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6045   float jresult ;
6046   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6047   float result;
6048
6049   arg1 = (Dali::Vector3 *)jarg1;
6050   {
6051     try {
6052       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6053     } catch (std::out_of_range& e) {
6054       {
6055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6056       };
6057     } catch (std::exception& e) {
6058       {
6059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6060       };
6061     } catch (...) {
6062       {
6063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6064       };
6065     }
6066   }
6067   jresult = result;
6068   return jresult;
6069 }
6070
6071
6072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6073   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6074
6075   arg1 = (Dali::Vector3 *)jarg1;
6076   {
6077     try {
6078       (arg1)->Normalize();
6079     } catch (std::out_of_range& e) {
6080       {
6081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6082       };
6083     } catch (std::exception& e) {
6084       {
6085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6086       };
6087     } catch (...) {
6088       {
6089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6090       };
6091     }
6092   }
6093 }
6094
6095
6096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6097   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6098   Dali::Vector3 *arg2 = 0 ;
6099   Dali::Vector3 *arg3 = 0 ;
6100
6101   arg1 = (Dali::Vector3 *)jarg1;
6102   arg2 = (Dali::Vector3 *)jarg2;
6103   if (!arg2) {
6104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6105     return ;
6106   }
6107   arg3 = (Dali::Vector3 *)jarg3;
6108   if (!arg3) {
6109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6110     return ;
6111   }
6112   {
6113     try {
6114       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6115     } catch (std::out_of_range& e) {
6116       {
6117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6118       };
6119     } catch (std::exception& e) {
6120       {
6121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6122       };
6123     } catch (...) {
6124       {
6125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6126       };
6127     }
6128   }
6129 }
6130
6131
6132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6133   void * jresult ;
6134   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6135   float *result = 0 ;
6136
6137   arg1 = (Dali::Vector3 *)jarg1;
6138   {
6139     try {
6140       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6141     } catch (std::out_of_range& e) {
6142       {
6143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6144       };
6145     } catch (std::exception& e) {
6146       {
6147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6148       };
6149     } catch (...) {
6150       {
6151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6152       };
6153     }
6154   }
6155   jresult = (void *)result;
6156   return jresult;
6157 }
6158
6159
6160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6161   void * jresult ;
6162   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6163   Dali::Vector2 *result = 0 ;
6164
6165   arg1 = (Dali::Vector3 *)jarg1;
6166   {
6167     try {
6168       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6169     } catch (std::out_of_range& e) {
6170       {
6171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6172       };
6173     } catch (std::exception& e) {
6174       {
6175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6176       };
6177     } catch (...) {
6178       {
6179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6180       };
6181     }
6182   }
6183   jresult = (void *)result;
6184   return jresult;
6185 }
6186
6187
6188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6189   void * jresult ;
6190   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6191   Dali::Vector2 *result = 0 ;
6192
6193   arg1 = (Dali::Vector3 *)jarg1;
6194   {
6195     try {
6196       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6197     } catch (std::out_of_range& e) {
6198       {
6199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6200       };
6201     } catch (std::exception& e) {
6202       {
6203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6204       };
6205     } catch (...) {
6206       {
6207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6208       };
6209     }
6210   }
6211   jresult = (void *)result;
6212   return jresult;
6213 }
6214
6215
6216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6217   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6218   float arg2 ;
6219
6220   arg1 = (Dali::Vector3 *)jarg1;
6221   arg2 = (float)jarg2;
6222   if (arg1) (arg1)->x = arg2;
6223 }
6224
6225
6226 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6227   float jresult ;
6228   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6229   float result;
6230
6231   arg1 = (Dali::Vector3 *)jarg1;
6232   result = (float) ((arg1)->x);
6233   jresult = result;
6234   return jresult;
6235 }
6236
6237
6238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6239   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6240   float arg2 ;
6241
6242   arg1 = (Dali::Vector3 *)jarg1;
6243   arg2 = (float)jarg2;
6244   if (arg1) (arg1)->width = arg2;
6245 }
6246
6247
6248 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6249   float jresult ;
6250   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6251   float result;
6252
6253   arg1 = (Dali::Vector3 *)jarg1;
6254   result = (float) ((arg1)->width);
6255   jresult = result;
6256   return jresult;
6257 }
6258
6259
6260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6261   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6262   float arg2 ;
6263
6264   arg1 = (Dali::Vector3 *)jarg1;
6265   arg2 = (float)jarg2;
6266   if (arg1) (arg1)->r = arg2;
6267 }
6268
6269
6270 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6271   float jresult ;
6272   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6273   float result;
6274
6275   arg1 = (Dali::Vector3 *)jarg1;
6276   result = (float) ((arg1)->r);
6277   jresult = result;
6278   return jresult;
6279 }
6280
6281
6282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6283   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6284   float arg2 ;
6285
6286   arg1 = (Dali::Vector3 *)jarg1;
6287   arg2 = (float)jarg2;
6288   if (arg1) (arg1)->y = arg2;
6289 }
6290
6291
6292 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6293   float jresult ;
6294   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6295   float result;
6296
6297   arg1 = (Dali::Vector3 *)jarg1;
6298   result = (float) ((arg1)->y);
6299   jresult = result;
6300   return jresult;
6301 }
6302
6303
6304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6305   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6306   float arg2 ;
6307
6308   arg1 = (Dali::Vector3 *)jarg1;
6309   arg2 = (float)jarg2;
6310   if (arg1) (arg1)->height = arg2;
6311 }
6312
6313
6314 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6315   float jresult ;
6316   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6317   float result;
6318
6319   arg1 = (Dali::Vector3 *)jarg1;
6320   result = (float) ((arg1)->height);
6321   jresult = result;
6322   return jresult;
6323 }
6324
6325
6326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
6327   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6328   float arg2 ;
6329
6330   arg1 = (Dali::Vector3 *)jarg1;
6331   arg2 = (float)jarg2;
6332   if (arg1) (arg1)->g = arg2;
6333 }
6334
6335
6336 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
6337   float jresult ;
6338   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6339   float result;
6340
6341   arg1 = (Dali::Vector3 *)jarg1;
6342   result = (float) ((arg1)->g);
6343   jresult = result;
6344   return jresult;
6345 }
6346
6347
6348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
6349   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6350   float arg2 ;
6351
6352   arg1 = (Dali::Vector3 *)jarg1;
6353   arg2 = (float)jarg2;
6354   if (arg1) (arg1)->z = arg2;
6355 }
6356
6357
6358 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
6359   float jresult ;
6360   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6361   float result;
6362
6363   arg1 = (Dali::Vector3 *)jarg1;
6364   result = (float) ((arg1)->z);
6365   jresult = result;
6366   return jresult;
6367 }
6368
6369
6370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
6371   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6372   float arg2 ;
6373
6374   arg1 = (Dali::Vector3 *)jarg1;
6375   arg2 = (float)jarg2;
6376   if (arg1) (arg1)->depth = arg2;
6377 }
6378
6379
6380 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
6381   float jresult ;
6382   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6383   float result;
6384
6385   arg1 = (Dali::Vector3 *)jarg1;
6386   result = (float) ((arg1)->depth);
6387   jresult = result;
6388   return jresult;
6389 }
6390
6391
6392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
6393   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6394   float arg2 ;
6395
6396   arg1 = (Dali::Vector3 *)jarg1;
6397   arg2 = (float)jarg2;
6398   if (arg1) (arg1)->b = arg2;
6399 }
6400
6401
6402 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
6403   float jresult ;
6404   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6405   float result;
6406
6407   arg1 = (Dali::Vector3 *)jarg1;
6408   result = (float) ((arg1)->b);
6409   jresult = result;
6410   return jresult;
6411 }
6412
6413
6414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
6415   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6416
6417   arg1 = (Dali::Vector3 *)jarg1;
6418   {
6419     try {
6420       delete arg1;
6421     } catch (std::out_of_range& e) {
6422       {
6423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6424       };
6425     } catch (std::exception& e) {
6426       {
6427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6428       };
6429     } catch (...) {
6430       {
6431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6432       };
6433     }
6434   }
6435 }
6436
6437
6438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
6439   void * jresult ;
6440   Dali::Vector3 *arg1 = 0 ;
6441   Dali::Vector3 *arg2 = 0 ;
6442   Dali::Vector3 result;
6443
6444   arg1 = (Dali::Vector3 *)jarg1;
6445   if (!arg1) {
6446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6447     return 0;
6448   }
6449   arg2 = (Dali::Vector3 *)jarg2;
6450   if (!arg2) {
6451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6452     return 0;
6453   }
6454   {
6455     try {
6456       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6457     } catch (std::out_of_range& e) {
6458       {
6459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6460       };
6461     } catch (std::exception& e) {
6462       {
6463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6464       };
6465     } catch (...) {
6466       {
6467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6468       };
6469     }
6470   }
6471   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6472   return jresult;
6473 }
6474
6475
6476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
6477   void * jresult ;
6478   Dali::Vector3 *arg1 = 0 ;
6479   Dali::Vector3 *arg2 = 0 ;
6480   Dali::Vector3 result;
6481
6482   arg1 = (Dali::Vector3 *)jarg1;
6483   if (!arg1) {
6484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6485     return 0;
6486   }
6487   arg2 = (Dali::Vector3 *)jarg2;
6488   if (!arg2) {
6489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6490     return 0;
6491   }
6492   {
6493     try {
6494       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6495     } catch (std::out_of_range& e) {
6496       {
6497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6498       };
6499     } catch (std::exception& e) {
6500       {
6501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6502       };
6503     } catch (...) {
6504       {
6505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6506       };
6507     }
6508   }
6509   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6510   return jresult;
6511 }
6512
6513
6514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
6515   void * jresult ;
6516   Dali::Vector3 *arg1 = 0 ;
6517   float *arg2 = 0 ;
6518   float *arg3 = 0 ;
6519   float temp2 ;
6520   float temp3 ;
6521   Dali::Vector3 result;
6522
6523   arg1 = (Dali::Vector3 *)jarg1;
6524   if (!arg1) {
6525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6526     return 0;
6527   }
6528   temp2 = (float)jarg2;
6529   arg2 = &temp2;
6530   temp3 = (float)jarg3;
6531   arg3 = &temp3;
6532   {
6533     try {
6534       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
6535     } catch (std::out_of_range& e) {
6536       {
6537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6538       };
6539     } catch (std::exception& e) {
6540       {
6541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6542       };
6543     } catch (...) {
6544       {
6545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6546       };
6547     }
6548   }
6549   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6550   return jresult;
6551 }
6552
6553
6554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
6555   void * jresult ;
6556   Dali::Vector4 *result = 0 ;
6557
6558   {
6559     try {
6560       result = (Dali::Vector4 *)new Dali::Vector4();
6561     } catch (std::out_of_range& e) {
6562       {
6563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6564       };
6565     } catch (std::exception& e) {
6566       {
6567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6568       };
6569     } catch (...) {
6570       {
6571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6572       };
6573     }
6574   }
6575   jresult = (void *)result;
6576   return jresult;
6577 }
6578
6579
6580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
6581   void * jresult ;
6582   float arg1 ;
6583   float arg2 ;
6584   float arg3 ;
6585   float arg4 ;
6586   Dali::Vector4 *result = 0 ;
6587
6588   arg1 = (float)jarg1;
6589   arg2 = (float)jarg2;
6590   arg3 = (float)jarg3;
6591   arg4 = (float)jarg4;
6592   {
6593     try {
6594       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
6595     } catch (std::out_of_range& e) {
6596       {
6597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6598       };
6599     } catch (std::exception& e) {
6600       {
6601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6602       };
6603     } catch (...) {
6604       {
6605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6606       };
6607     }
6608   }
6609   jresult = (void *)result;
6610   return jresult;
6611 }
6612
6613
6614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
6615   void * jresult ;
6616   float *arg1 = (float *) 0 ;
6617   Dali::Vector4 *result = 0 ;
6618
6619   arg1 = jarg1;
6620   {
6621     try {
6622       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
6623     } catch (std::out_of_range& e) {
6624       {
6625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6626       };
6627     } catch (std::exception& e) {
6628       {
6629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6630       };
6631     } catch (...) {
6632       {
6633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6634       };
6635     }
6636   }
6637   jresult = (void *)result;
6638
6639
6640   return jresult;
6641 }
6642
6643
6644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
6645   void * jresult ;
6646   Dali::Vector2 *arg1 = 0 ;
6647   Dali::Vector4 *result = 0 ;
6648
6649   arg1 = (Dali::Vector2 *)jarg1;
6650   if (!arg1) {
6651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6652     return 0;
6653   }
6654   {
6655     try {
6656       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
6657     } catch (std::out_of_range& e) {
6658       {
6659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6660       };
6661     } catch (std::exception& e) {
6662       {
6663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6664       };
6665     } catch (...) {
6666       {
6667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6668       };
6669     }
6670   }
6671   jresult = (void *)result;
6672   return jresult;
6673 }
6674
6675
6676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
6677   void * jresult ;
6678   Dali::Vector3 *arg1 = 0 ;
6679   Dali::Vector4 *result = 0 ;
6680
6681   arg1 = (Dali::Vector3 *)jarg1;
6682   if (!arg1) {
6683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6684     return 0;
6685   }
6686   {
6687     try {
6688       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
6689     } catch (std::out_of_range& e) {
6690       {
6691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6692       };
6693     } catch (std::exception& e) {
6694       {
6695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6696       };
6697     } catch (...) {
6698       {
6699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6700       };
6701     }
6702   }
6703   jresult = (void *)result;
6704   return jresult;
6705 }
6706
6707
6708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
6709   void * jresult ;
6710   Dali::Vector4 *result = 0 ;
6711
6712   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
6713   jresult = (void *)result;
6714   return jresult;
6715 }
6716
6717
6718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
6719   void * jresult ;
6720   Dali::Vector4 *result = 0 ;
6721
6722   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
6723   jresult = (void *)result;
6724   return jresult;
6725 }
6726
6727
6728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
6729   void * jresult ;
6730   Dali::Vector4 *result = 0 ;
6731
6732   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
6733   jresult = (void *)result;
6734   return jresult;
6735 }
6736
6737
6738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
6739   void * jresult ;
6740   Dali::Vector4 *result = 0 ;
6741
6742   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
6743   jresult = (void *)result;
6744   return jresult;
6745 }
6746
6747
6748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
6749   void * jresult ;
6750   Dali::Vector4 *result = 0 ;
6751
6752   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
6753   jresult = (void *)result;
6754   return jresult;
6755 }
6756
6757
6758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
6759   void * jresult ;
6760   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6761   float *arg2 = (float *) 0 ;
6762   Dali::Vector4 *result = 0 ;
6763
6764   arg1 = (Dali::Vector4 *)jarg1;
6765   arg2 = jarg2;
6766   {
6767     try {
6768       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
6769     } catch (std::out_of_range& e) {
6770       {
6771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6772       };
6773     } catch (std::exception& e) {
6774       {
6775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6776       };
6777     } catch (...) {
6778       {
6779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6780       };
6781     }
6782   }
6783   jresult = (void *)result;
6784
6785
6786   return jresult;
6787 }
6788
6789
6790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
6791   void * jresult ;
6792   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6793   Dali::Vector2 *arg2 = 0 ;
6794   Dali::Vector4 *result = 0 ;
6795
6796   arg1 = (Dali::Vector4 *)jarg1;
6797   arg2 = (Dali::Vector2 *)jarg2;
6798   if (!arg2) {
6799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6800     return 0;
6801   }
6802   {
6803     try {
6804       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
6805     } catch (std::out_of_range& e) {
6806       {
6807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6808       };
6809     } catch (std::exception& e) {
6810       {
6811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6812       };
6813     } catch (...) {
6814       {
6815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6816       };
6817     }
6818   }
6819   jresult = (void *)result;
6820   return jresult;
6821 }
6822
6823
6824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
6825   void * jresult ;
6826   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6827   Dali::Vector3 *arg2 = 0 ;
6828   Dali::Vector4 *result = 0 ;
6829
6830   arg1 = (Dali::Vector4 *)jarg1;
6831   arg2 = (Dali::Vector3 *)jarg2;
6832   if (!arg2) {
6833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6834     return 0;
6835   }
6836   {
6837     try {
6838       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
6839     } catch (std::out_of_range& e) {
6840       {
6841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6842       };
6843     } catch (std::exception& e) {
6844       {
6845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6846       };
6847     } catch (...) {
6848       {
6849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6850       };
6851     }
6852   }
6853   jresult = (void *)result;
6854   return jresult;
6855 }
6856
6857
6858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
6859   void * jresult ;
6860   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6861   Dali::Vector4 *arg2 = 0 ;
6862   Dali::Vector4 result;
6863
6864   arg1 = (Dali::Vector4 *)jarg1;
6865   arg2 = (Dali::Vector4 *)jarg2;
6866   if (!arg2) {
6867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6868     return 0;
6869   }
6870   {
6871     try {
6872       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
6873     } catch (std::out_of_range& e) {
6874       {
6875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6876       };
6877     } catch (std::exception& e) {
6878       {
6879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6880       };
6881     } catch (...) {
6882       {
6883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6884       };
6885     }
6886   }
6887   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6888   return jresult;
6889 }
6890
6891
6892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
6893   void * jresult ;
6894   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6895   Dali::Vector4 *arg2 = 0 ;
6896   Dali::Vector4 *result = 0 ;
6897
6898   arg1 = (Dali::Vector4 *)jarg1;
6899   arg2 = (Dali::Vector4 *)jarg2;
6900   if (!arg2) {
6901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6902     return 0;
6903   }
6904   {
6905     try {
6906       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
6907     } catch (std::out_of_range& e) {
6908       {
6909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6910       };
6911     } catch (std::exception& e) {
6912       {
6913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6914       };
6915     } catch (...) {
6916       {
6917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6918       };
6919     }
6920   }
6921   jresult = (void *)result;
6922   return jresult;
6923 }
6924
6925
6926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6927   void * jresult ;
6928   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6929   Dali::Vector4 *arg2 = 0 ;
6930   Dali::Vector4 result;
6931
6932   arg1 = (Dali::Vector4 *)jarg1;
6933   arg2 = (Dali::Vector4 *)jarg2;
6934   if (!arg2) {
6935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6936     return 0;
6937   }
6938   {
6939     try {
6940       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
6941     } catch (std::out_of_range& e) {
6942       {
6943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6944       };
6945     } catch (std::exception& e) {
6946       {
6947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6948       };
6949     } catch (...) {
6950       {
6951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6952       };
6953     }
6954   }
6955   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6956   return jresult;
6957 }
6958
6959
6960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
6961   void * jresult ;
6962   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6963   Dali::Vector4 *arg2 = 0 ;
6964   Dali::Vector4 *result = 0 ;
6965
6966   arg1 = (Dali::Vector4 *)jarg1;
6967   arg2 = (Dali::Vector4 *)jarg2;
6968   if (!arg2) {
6969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6970     return 0;
6971   }
6972   {
6973     try {
6974       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
6975     } catch (std::out_of_range& e) {
6976       {
6977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6978       };
6979     } catch (std::exception& e) {
6980       {
6981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6982       };
6983     } catch (...) {
6984       {
6985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6986       };
6987     }
6988   }
6989   jresult = (void *)result;
6990   return jresult;
6991 }
6992
6993
6994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6995   void * jresult ;
6996   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6997   Dali::Vector4 *arg2 = 0 ;
6998   Dali::Vector4 result;
6999
7000   arg1 = (Dali::Vector4 *)jarg1;
7001   arg2 = (Dali::Vector4 *)jarg2;
7002   if (!arg2) {
7003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7004     return 0;
7005   }
7006   {
7007     try {
7008       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7009     } catch (std::out_of_range& e) {
7010       {
7011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7012       };
7013     } catch (std::exception& e) {
7014       {
7015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7016       };
7017     } catch (...) {
7018       {
7019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7020       };
7021     }
7022   }
7023   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7024   return jresult;
7025 }
7026
7027
7028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7029   void * jresult ;
7030   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7031   float arg2 ;
7032   Dali::Vector4 result;
7033
7034   arg1 = (Dali::Vector4 *)jarg1;
7035   arg2 = (float)jarg2;
7036   {
7037     try {
7038       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7039     } catch (std::out_of_range& e) {
7040       {
7041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7042       };
7043     } catch (std::exception& e) {
7044       {
7045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7046       };
7047     } catch (...) {
7048       {
7049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7050       };
7051     }
7052   }
7053   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7054   return jresult;
7055 }
7056
7057
7058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7059   void * jresult ;
7060   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7061   Dali::Vector4 *arg2 = 0 ;
7062   Dali::Vector4 *result = 0 ;
7063
7064   arg1 = (Dali::Vector4 *)jarg1;
7065   arg2 = (Dali::Vector4 *)jarg2;
7066   if (!arg2) {
7067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7068     return 0;
7069   }
7070   {
7071     try {
7072       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7073     } catch (std::out_of_range& e) {
7074       {
7075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7076       };
7077     } catch (std::exception& e) {
7078       {
7079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7080       };
7081     } catch (...) {
7082       {
7083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7084       };
7085     }
7086   }
7087   jresult = (void *)result;
7088   return jresult;
7089 }
7090
7091
7092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7093   void * jresult ;
7094   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7095   float arg2 ;
7096   Dali::Vector4 *result = 0 ;
7097
7098   arg1 = (Dali::Vector4 *)jarg1;
7099   arg2 = (float)jarg2;
7100   {
7101     try {
7102       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7103     } catch (std::out_of_range& e) {
7104       {
7105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7106       };
7107     } catch (std::exception& e) {
7108       {
7109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7110       };
7111     } catch (...) {
7112       {
7113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7114       };
7115     }
7116   }
7117   jresult = (void *)result;
7118   return jresult;
7119 }
7120
7121
7122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7123   void * jresult ;
7124   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7125   Dali::Vector4 *arg2 = 0 ;
7126   Dali::Vector4 result;
7127
7128   arg1 = (Dali::Vector4 *)jarg1;
7129   arg2 = (Dali::Vector4 *)jarg2;
7130   if (!arg2) {
7131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7132     return 0;
7133   }
7134   {
7135     try {
7136       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7137     } catch (std::out_of_range& e) {
7138       {
7139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7140       };
7141     } catch (std::exception& e) {
7142       {
7143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7144       };
7145     } catch (...) {
7146       {
7147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7148       };
7149     }
7150   }
7151   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7152   return jresult;
7153 }
7154
7155
7156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7157   void * jresult ;
7158   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7159   float arg2 ;
7160   Dali::Vector4 result;
7161
7162   arg1 = (Dali::Vector4 *)jarg1;
7163   arg2 = (float)jarg2;
7164   {
7165     try {
7166       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7167     } catch (std::out_of_range& e) {
7168       {
7169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7170       };
7171     } catch (std::exception& e) {
7172       {
7173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7174       };
7175     } catch (...) {
7176       {
7177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7178       };
7179     }
7180   }
7181   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7182   return jresult;
7183 }
7184
7185
7186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7187   void * jresult ;
7188   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7189   Dali::Vector4 *arg2 = 0 ;
7190   Dali::Vector4 *result = 0 ;
7191
7192   arg1 = (Dali::Vector4 *)jarg1;
7193   arg2 = (Dali::Vector4 *)jarg2;
7194   if (!arg2) {
7195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7196     return 0;
7197   }
7198   {
7199     try {
7200       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7201     } catch (std::out_of_range& e) {
7202       {
7203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7204       };
7205     } catch (std::exception& e) {
7206       {
7207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7208       };
7209     } catch (...) {
7210       {
7211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7212       };
7213     }
7214   }
7215   jresult = (void *)result;
7216   return jresult;
7217 }
7218
7219
7220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7221   void * jresult ;
7222   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7223   float arg2 ;
7224   Dali::Vector4 *result = 0 ;
7225
7226   arg1 = (Dali::Vector4 *)jarg1;
7227   arg2 = (float)jarg2;
7228   {
7229     try {
7230       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
7231     } catch (std::out_of_range& e) {
7232       {
7233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7234       };
7235     } catch (std::exception& e) {
7236       {
7237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7238       };
7239     } catch (...) {
7240       {
7241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7242       };
7243     }
7244   }
7245   jresult = (void *)result;
7246   return jresult;
7247 }
7248
7249
7250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
7251   void * jresult ;
7252   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7253   Dali::Vector4 result;
7254
7255   arg1 = (Dali::Vector4 *)jarg1;
7256   {
7257     try {
7258       result = ((Dali::Vector4 const *)arg1)->operator -();
7259     } catch (std::out_of_range& e) {
7260       {
7261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7262       };
7263     } catch (std::exception& e) {
7264       {
7265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7266       };
7267     } catch (...) {
7268       {
7269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7270       };
7271     }
7272   }
7273   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7274   return jresult;
7275 }
7276
7277
7278 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
7279   unsigned int jresult ;
7280   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7281   Dali::Vector4 *arg2 = 0 ;
7282   bool result;
7283
7284   arg1 = (Dali::Vector4 *)jarg1;
7285   arg2 = (Dali::Vector4 *)jarg2;
7286   if (!arg2) {
7287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7288     return 0;
7289   }
7290   {
7291     try {
7292       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
7293     } catch (std::out_of_range& e) {
7294       {
7295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7296       };
7297     } catch (std::exception& e) {
7298       {
7299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7300       };
7301     } catch (...) {
7302       {
7303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7304       };
7305     }
7306   }
7307   jresult = result;
7308   return jresult;
7309 }
7310
7311
7312 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
7313   unsigned int jresult ;
7314   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7315   Dali::Vector4 *arg2 = 0 ;
7316   bool result;
7317
7318   arg1 = (Dali::Vector4 *)jarg1;
7319   arg2 = (Dali::Vector4 *)jarg2;
7320   if (!arg2) {
7321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7322     return 0;
7323   }
7324   {
7325     try {
7326       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
7327     } catch (std::out_of_range& e) {
7328       {
7329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7330       };
7331     } catch (std::exception& e) {
7332       {
7333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7334       };
7335     } catch (...) {
7336       {
7337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7338       };
7339     }
7340   }
7341   jresult = result;
7342   return jresult;
7343 }
7344
7345
7346 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
7347   float jresult ;
7348   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7349   unsigned int arg2 ;
7350   float *result = 0 ;
7351
7352   arg1 = (Dali::Vector4 *)jarg1;
7353   arg2 = (unsigned int)jarg2;
7354   {
7355     try {
7356       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
7357     } catch (std::out_of_range& e) {
7358       {
7359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7360       };
7361     } catch (std::exception& e) {
7362       {
7363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7364       };
7365     } catch (...) {
7366       {
7367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7368       };
7369     }
7370   }
7371   jresult = *result;
7372   return jresult;
7373 }
7374
7375
7376 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
7377   float jresult ;
7378   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7379   Dali::Vector3 *arg2 = 0 ;
7380   float result;
7381
7382   arg1 = (Dali::Vector4 *)jarg1;
7383   arg2 = (Dali::Vector3 *)jarg2;
7384   if (!arg2) {
7385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7386     return 0;
7387   }
7388   {
7389     try {
7390       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
7391     } catch (std::out_of_range& e) {
7392       {
7393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7394       };
7395     } catch (std::exception& e) {
7396       {
7397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7398       };
7399     } catch (...) {
7400       {
7401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7402       };
7403     }
7404   }
7405   jresult = result;
7406   return jresult;
7407 }
7408
7409
7410 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
7411   float jresult ;
7412   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7413   Dali::Vector4 *arg2 = 0 ;
7414   float result;
7415
7416   arg1 = (Dali::Vector4 *)jarg1;
7417   arg2 = (Dali::Vector4 *)jarg2;
7418   if (!arg2) {
7419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7420     return 0;
7421   }
7422   {
7423     try {
7424       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
7425     } catch (std::out_of_range& e) {
7426       {
7427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7428       };
7429     } catch (std::exception& e) {
7430       {
7431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7432       };
7433     } catch (...) {
7434       {
7435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7436       };
7437     }
7438   }
7439   jresult = result;
7440   return jresult;
7441 }
7442
7443
7444 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
7445   float jresult ;
7446   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7447   Dali::Vector4 *arg2 = 0 ;
7448   float result;
7449
7450   arg1 = (Dali::Vector4 *)jarg1;
7451   arg2 = (Dali::Vector4 *)jarg2;
7452   if (!arg2) {
7453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7454     return 0;
7455   }
7456   {
7457     try {
7458       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
7459     } catch (std::out_of_range& e) {
7460       {
7461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7462       };
7463     } catch (std::exception& e) {
7464       {
7465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7466       };
7467     } catch (...) {
7468       {
7469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7470       };
7471     }
7472   }
7473   jresult = result;
7474   return jresult;
7475 }
7476
7477
7478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
7479   void * jresult ;
7480   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7481   Dali::Vector4 *arg2 = 0 ;
7482   Dali::Vector4 result;
7483
7484   arg1 = (Dali::Vector4 *)jarg1;
7485   arg2 = (Dali::Vector4 *)jarg2;
7486   if (!arg2) {
7487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7488     return 0;
7489   }
7490   {
7491     try {
7492       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
7493     } catch (std::out_of_range& e) {
7494       {
7495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7496       };
7497     } catch (std::exception& e) {
7498       {
7499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7500       };
7501     } catch (...) {
7502       {
7503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7504       };
7505     }
7506   }
7507   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7508   return jresult;
7509 }
7510
7511
7512 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
7513   float jresult ;
7514   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7515   float result;
7516
7517   arg1 = (Dali::Vector4 *)jarg1;
7518   {
7519     try {
7520       result = (float)((Dali::Vector4 const *)arg1)->Length();
7521     } catch (std::out_of_range& e) {
7522       {
7523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7524       };
7525     } catch (std::exception& e) {
7526       {
7527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7528       };
7529     } catch (...) {
7530       {
7531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7532       };
7533     }
7534   }
7535   jresult = result;
7536   return jresult;
7537 }
7538
7539
7540 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
7541   float jresult ;
7542   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7543   float result;
7544
7545   arg1 = (Dali::Vector4 *)jarg1;
7546   {
7547     try {
7548       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
7549     } catch (std::out_of_range& e) {
7550       {
7551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7552       };
7553     } catch (std::exception& e) {
7554       {
7555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7556       };
7557     } catch (...) {
7558       {
7559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7560       };
7561     }
7562   }
7563   jresult = result;
7564   return jresult;
7565 }
7566
7567
7568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
7569   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7570
7571   arg1 = (Dali::Vector4 *)jarg1;
7572   {
7573     try {
7574       (arg1)->Normalize();
7575     } catch (std::out_of_range& e) {
7576       {
7577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7578       };
7579     } catch (std::exception& e) {
7580       {
7581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7582       };
7583     } catch (...) {
7584       {
7585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7586       };
7587     }
7588   }
7589 }
7590
7591
7592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
7593   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7594   Dali::Vector4 *arg2 = 0 ;
7595   Dali::Vector4 *arg3 = 0 ;
7596
7597   arg1 = (Dali::Vector4 *)jarg1;
7598   arg2 = (Dali::Vector4 *)jarg2;
7599   if (!arg2) {
7600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7601     return ;
7602   }
7603   arg3 = (Dali::Vector4 *)jarg3;
7604   if (!arg3) {
7605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7606     return ;
7607   }
7608   {
7609     try {
7610       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
7611     } catch (std::out_of_range& e) {
7612       {
7613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7614       };
7615     } catch (std::exception& e) {
7616       {
7617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7618       };
7619     } catch (...) {
7620       {
7621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7622       };
7623     }
7624   }
7625 }
7626
7627
7628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
7629   void * jresult ;
7630   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7631   float *result = 0 ;
7632
7633   arg1 = (Dali::Vector4 *)jarg1;
7634   {
7635     try {
7636       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
7637     } catch (std::out_of_range& e) {
7638       {
7639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7640       };
7641     } catch (std::exception& e) {
7642       {
7643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7644       };
7645     } catch (...) {
7646       {
7647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7648       };
7649     }
7650   }
7651   jresult = (void *)result;
7652   return jresult;
7653 }
7654
7655
7656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
7657   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7658   float arg2 ;
7659
7660   arg1 = (Dali::Vector4 *)jarg1;
7661   arg2 = (float)jarg2;
7662   if (arg1) (arg1)->x = arg2;
7663 }
7664
7665
7666 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
7667   float jresult ;
7668   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7669   float result;
7670
7671   arg1 = (Dali::Vector4 *)jarg1;
7672   result = (float) ((arg1)->x);
7673   jresult = result;
7674   return jresult;
7675 }
7676
7677
7678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
7679   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7680   float arg2 ;
7681
7682   arg1 = (Dali::Vector4 *)jarg1;
7683   arg2 = (float)jarg2;
7684   if (arg1) (arg1)->r = arg2;
7685 }
7686
7687
7688 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
7689   float jresult ;
7690   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7691   float result;
7692
7693   arg1 = (Dali::Vector4 *)jarg1;
7694   result = (float) ((arg1)->r);
7695   jresult = result;
7696   return jresult;
7697 }
7698
7699
7700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
7701   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7702   float arg2 ;
7703
7704   arg1 = (Dali::Vector4 *)jarg1;
7705   arg2 = (float)jarg2;
7706   if (arg1) (arg1)->s = arg2;
7707 }
7708
7709
7710 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
7711   float jresult ;
7712   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7713   float result;
7714
7715   arg1 = (Dali::Vector4 *)jarg1;
7716   result = (float) ((arg1)->s);
7717   jresult = result;
7718   return jresult;
7719 }
7720
7721
7722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
7723   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7724   float arg2 ;
7725
7726   arg1 = (Dali::Vector4 *)jarg1;
7727   arg2 = (float)jarg2;
7728   if (arg1) (arg1)->y = arg2;
7729 }
7730
7731
7732 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
7733   float jresult ;
7734   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7735   float result;
7736
7737   arg1 = (Dali::Vector4 *)jarg1;
7738   result = (float) ((arg1)->y);
7739   jresult = result;
7740   return jresult;
7741 }
7742
7743
7744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
7745   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7746   float arg2 ;
7747
7748   arg1 = (Dali::Vector4 *)jarg1;
7749   arg2 = (float)jarg2;
7750   if (arg1) (arg1)->g = arg2;
7751 }
7752
7753
7754 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
7755   float jresult ;
7756   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7757   float result;
7758
7759   arg1 = (Dali::Vector4 *)jarg1;
7760   result = (float) ((arg1)->g);
7761   jresult = result;
7762   return jresult;
7763 }
7764
7765
7766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
7767   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7768   float arg2 ;
7769
7770   arg1 = (Dali::Vector4 *)jarg1;
7771   arg2 = (float)jarg2;
7772   if (arg1) (arg1)->t = arg2;
7773 }
7774
7775
7776 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
7777   float jresult ;
7778   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7779   float result;
7780
7781   arg1 = (Dali::Vector4 *)jarg1;
7782   result = (float) ((arg1)->t);
7783   jresult = result;
7784   return jresult;
7785 }
7786
7787
7788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
7789   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7790   float arg2 ;
7791
7792   arg1 = (Dali::Vector4 *)jarg1;
7793   arg2 = (float)jarg2;
7794   if (arg1) (arg1)->z = arg2;
7795 }
7796
7797
7798 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
7799   float jresult ;
7800   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7801   float result;
7802
7803   arg1 = (Dali::Vector4 *)jarg1;
7804   result = (float) ((arg1)->z);
7805   jresult = result;
7806   return jresult;
7807 }
7808
7809
7810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
7811   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7812   float arg2 ;
7813
7814   arg1 = (Dali::Vector4 *)jarg1;
7815   arg2 = (float)jarg2;
7816   if (arg1) (arg1)->b = arg2;
7817 }
7818
7819
7820 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
7821   float jresult ;
7822   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7823   float result;
7824
7825   arg1 = (Dali::Vector4 *)jarg1;
7826   result = (float) ((arg1)->b);
7827   jresult = result;
7828   return jresult;
7829 }
7830
7831
7832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
7833   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7834   float arg2 ;
7835
7836   arg1 = (Dali::Vector4 *)jarg1;
7837   arg2 = (float)jarg2;
7838   if (arg1) (arg1)->p = arg2;
7839 }
7840
7841
7842 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
7843   float jresult ;
7844   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7845   float result;
7846
7847   arg1 = (Dali::Vector4 *)jarg1;
7848   result = (float) ((arg1)->p);
7849   jresult = result;
7850   return jresult;
7851 }
7852
7853
7854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
7855   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7856   float arg2 ;
7857
7858   arg1 = (Dali::Vector4 *)jarg1;
7859   arg2 = (float)jarg2;
7860   if (arg1) (arg1)->w = arg2;
7861 }
7862
7863
7864 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
7865   float jresult ;
7866   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7867   float result;
7868
7869   arg1 = (Dali::Vector4 *)jarg1;
7870   result = (float) ((arg1)->w);
7871   jresult = result;
7872   return jresult;
7873 }
7874
7875
7876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
7877   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7878   float arg2 ;
7879
7880   arg1 = (Dali::Vector4 *)jarg1;
7881   arg2 = (float)jarg2;
7882   if (arg1) (arg1)->a = arg2;
7883 }
7884
7885
7886 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
7887   float jresult ;
7888   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7889   float result;
7890
7891   arg1 = (Dali::Vector4 *)jarg1;
7892   result = (float) ((arg1)->a);
7893   jresult = result;
7894   return jresult;
7895 }
7896
7897
7898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
7899   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7900   float arg2 ;
7901
7902   arg1 = (Dali::Vector4 *)jarg1;
7903   arg2 = (float)jarg2;
7904   if (arg1) (arg1)->q = arg2;
7905 }
7906
7907
7908 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
7909   float jresult ;
7910   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7911   float result;
7912
7913   arg1 = (Dali::Vector4 *)jarg1;
7914   result = (float) ((arg1)->q);
7915   jresult = result;
7916   return jresult;
7917 }
7918
7919
7920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
7921   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7922
7923   arg1 = (Dali::Vector4 *)jarg1;
7924   {
7925     try {
7926       delete arg1;
7927     } catch (std::out_of_range& e) {
7928       {
7929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7930       };
7931     } catch (std::exception& e) {
7932       {
7933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7934       };
7935     } catch (...) {
7936       {
7937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7938       };
7939     }
7940   }
7941 }
7942
7943
7944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
7945   void * jresult ;
7946   Dali::Vector4 *arg1 = 0 ;
7947   Dali::Vector4 *arg2 = 0 ;
7948   Dali::Vector4 result;
7949
7950   arg1 = (Dali::Vector4 *)jarg1;
7951   if (!arg1) {
7952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7953     return 0;
7954   }
7955   arg2 = (Dali::Vector4 *)jarg2;
7956   if (!arg2) {
7957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7958     return 0;
7959   }
7960   {
7961     try {
7962       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7963     } catch (std::out_of_range& e) {
7964       {
7965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7966       };
7967     } catch (std::exception& e) {
7968       {
7969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7970       };
7971     } catch (...) {
7972       {
7973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7974       };
7975     }
7976   }
7977   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7978   return jresult;
7979 }
7980
7981
7982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
7983   void * jresult ;
7984   Dali::Vector4 *arg1 = 0 ;
7985   Dali::Vector4 *arg2 = 0 ;
7986   Dali::Vector4 result;
7987
7988   arg1 = (Dali::Vector4 *)jarg1;
7989   if (!arg1) {
7990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7991     return 0;
7992   }
7993   arg2 = (Dali::Vector4 *)jarg2;
7994   if (!arg2) {
7995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7996     return 0;
7997   }
7998   {
7999     try {
8000       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8001     } catch (std::out_of_range& e) {
8002       {
8003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8004       };
8005     } catch (std::exception& e) {
8006       {
8007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8008       };
8009     } catch (...) {
8010       {
8011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8012       };
8013     }
8014   }
8015   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8016   return jresult;
8017 }
8018
8019
8020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8021   void * jresult ;
8022   Dali::Vector4 *arg1 = 0 ;
8023   float *arg2 = 0 ;
8024   float *arg3 = 0 ;
8025   float temp2 ;
8026   float temp3 ;
8027   Dali::Vector4 result;
8028
8029   arg1 = (Dali::Vector4 *)jarg1;
8030   if (!arg1) {
8031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8032     return 0;
8033   }
8034   temp2 = (float)jarg2;
8035   arg2 = &temp2;
8036   temp3 = (float)jarg3;
8037   arg3 = &temp3;
8038   {
8039     try {
8040       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8041     } catch (std::out_of_range& e) {
8042       {
8043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8044       };
8045     } catch (std::exception& e) {
8046       {
8047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8048       };
8049     } catch (...) {
8050       {
8051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8052       };
8053     }
8054   }
8055   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8056   return jresult;
8057 }
8058
8059
8060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8061   void * jresult ;
8062   Dali::Uint16Pair *result = 0 ;
8063
8064   {
8065     try {
8066       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8067     } catch (std::out_of_range& e) {
8068       {
8069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8070       };
8071     } catch (std::exception& e) {
8072       {
8073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8074       };
8075     } catch (...) {
8076       {
8077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8078       };
8079     }
8080   }
8081   jresult = (void *)result;
8082   return jresult;
8083 }
8084
8085
8086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8087   void * jresult ;
8088   uint32_t arg1 ;
8089   uint32_t arg2 ;
8090   Dali::Uint16Pair *result = 0 ;
8091
8092   arg1 = (uint32_t)jarg1;
8093   arg2 = (uint32_t)jarg2;
8094   {
8095     try {
8096       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8097     } catch (std::out_of_range& e) {
8098       {
8099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8100       };
8101     } catch (std::exception& e) {
8102       {
8103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8104       };
8105     } catch (...) {
8106       {
8107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8108       };
8109     }
8110   }
8111   jresult = (void *)result;
8112   return jresult;
8113 }
8114
8115
8116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
8117   void * jresult ;
8118   Dali::Uint16Pair *arg1 = 0 ;
8119   Dali::Uint16Pair *result = 0 ;
8120
8121   arg1 = (Dali::Uint16Pair *)jarg1;
8122   if (!arg1) {
8123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8124     return 0;
8125   }
8126   {
8127     try {
8128       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
8129     } catch (std::out_of_range& e) {
8130       {
8131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8132       };
8133     } catch (std::exception& e) {
8134       {
8135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8136       };
8137     } catch (...) {
8138       {
8139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8140       };
8141     }
8142   }
8143   jresult = (void *)result;
8144   return jresult;
8145 }
8146
8147
8148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
8149   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8150   uint16_t arg2 ;
8151
8152   arg1 = (Dali::Uint16Pair *)jarg1;
8153   arg2 = (uint16_t)jarg2;
8154   {
8155     try {
8156       (arg1)->SetWidth(arg2);
8157     } catch (std::out_of_range& e) {
8158       {
8159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8160       };
8161     } catch (std::exception& e) {
8162       {
8163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8164       };
8165     } catch (...) {
8166       {
8167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8168       };
8169     }
8170   }
8171 }
8172
8173
8174 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
8175   unsigned short jresult ;
8176   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8177   uint16_t result;
8178
8179   arg1 = (Dali::Uint16Pair *)jarg1;
8180   {
8181     try {
8182       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
8183     } catch (std::out_of_range& e) {
8184       {
8185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8186       };
8187     } catch (std::exception& e) {
8188       {
8189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8190       };
8191     } catch (...) {
8192       {
8193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8194       };
8195     }
8196   }
8197   jresult = result;
8198   return jresult;
8199 }
8200
8201
8202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
8203   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8204   uint16_t arg2 ;
8205
8206   arg1 = (Dali::Uint16Pair *)jarg1;
8207   arg2 = (uint16_t)jarg2;
8208   {
8209     try {
8210       (arg1)->SetHeight(arg2);
8211     } catch (std::out_of_range& e) {
8212       {
8213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8214       };
8215     } catch (std::exception& e) {
8216       {
8217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8218       };
8219     } catch (...) {
8220       {
8221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8222       };
8223     }
8224   }
8225 }
8226
8227
8228 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
8229   unsigned short jresult ;
8230   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8231   uint16_t result;
8232
8233   arg1 = (Dali::Uint16Pair *)jarg1;
8234   {
8235     try {
8236       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
8237     } catch (std::out_of_range& e) {
8238       {
8239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8240       };
8241     } catch (std::exception& e) {
8242       {
8243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8244       };
8245     } catch (...) {
8246       {
8247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8248       };
8249     }
8250   }
8251   jresult = result;
8252   return jresult;
8253 }
8254
8255
8256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
8257   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8258   uint16_t arg2 ;
8259
8260   arg1 = (Dali::Uint16Pair *)jarg1;
8261   arg2 = (uint16_t)jarg2;
8262   {
8263     try {
8264       (arg1)->SetX(arg2);
8265     } catch (std::out_of_range& e) {
8266       {
8267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8268       };
8269     } catch (std::exception& e) {
8270       {
8271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8272       };
8273     } catch (...) {
8274       {
8275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8276       };
8277     }
8278   }
8279 }
8280
8281
8282 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
8283   unsigned short jresult ;
8284   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8285   uint16_t result;
8286
8287   arg1 = (Dali::Uint16Pair *)jarg1;
8288   {
8289     try {
8290       result = ((Dali::Uint16Pair const *)arg1)->GetX();
8291     } catch (std::out_of_range& e) {
8292       {
8293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8294       };
8295     } catch (std::exception& e) {
8296       {
8297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8298       };
8299     } catch (...) {
8300       {
8301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8302       };
8303     }
8304   }
8305   jresult = result;
8306   return jresult;
8307 }
8308
8309
8310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
8311   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8312   uint16_t arg2 ;
8313
8314   arg1 = (Dali::Uint16Pair *)jarg1;
8315   arg2 = (uint16_t)jarg2;
8316   {
8317     try {
8318       (arg1)->SetY(arg2);
8319     } catch (std::out_of_range& e) {
8320       {
8321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8322       };
8323     } catch (std::exception& e) {
8324       {
8325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8326       };
8327     } catch (...) {
8328       {
8329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8330       };
8331     }
8332   }
8333 }
8334
8335
8336 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
8337   unsigned short jresult ;
8338   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8339   uint16_t result;
8340
8341   arg1 = (Dali::Uint16Pair *)jarg1;
8342   {
8343     try {
8344       result = ((Dali::Uint16Pair const *)arg1)->GetY();
8345     } catch (std::out_of_range& e) {
8346       {
8347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8348       };
8349     } catch (std::exception& e) {
8350       {
8351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8352       };
8353     } catch (...) {
8354       {
8355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8356       };
8357     }
8358   }
8359   jresult = result;
8360   return jresult;
8361 }
8362
8363
8364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
8365   void * jresult ;
8366   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8367   Dali::Uint16Pair *arg2 = 0 ;
8368   Dali::Uint16Pair *result = 0 ;
8369
8370   arg1 = (Dali::Uint16Pair *)jarg1;
8371   arg2 = (Dali::Uint16Pair *)jarg2;
8372   if (!arg2) {
8373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8374     return 0;
8375   }
8376   {
8377     try {
8378       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
8379     } catch (std::out_of_range& e) {
8380       {
8381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8382       };
8383     } catch (std::exception& e) {
8384       {
8385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8386       };
8387     } catch (...) {
8388       {
8389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8390       };
8391     }
8392   }
8393   jresult = (void *)result;
8394   return jresult;
8395 }
8396
8397
8398 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
8399   unsigned int jresult ;
8400   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8401   Dali::Uint16Pair *arg2 = 0 ;
8402   bool result;
8403
8404   arg1 = (Dali::Uint16Pair *)jarg1;
8405   arg2 = (Dali::Uint16Pair *)jarg2;
8406   if (!arg2) {
8407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8408     return 0;
8409   }
8410   {
8411     try {
8412       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
8413     } catch (std::out_of_range& e) {
8414       {
8415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8416       };
8417     } catch (std::exception& e) {
8418       {
8419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8420       };
8421     } catch (...) {
8422       {
8423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8424       };
8425     }
8426   }
8427   jresult = result;
8428   return jresult;
8429 }
8430
8431
8432 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
8433   unsigned int jresult ;
8434   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8435   Dali::Uint16Pair *arg2 = 0 ;
8436   bool result;
8437
8438   arg1 = (Dali::Uint16Pair *)jarg1;
8439   arg2 = (Dali::Uint16Pair *)jarg2;
8440   if (!arg2) {
8441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8442     return 0;
8443   }
8444   {
8445     try {
8446       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
8447     } catch (std::out_of_range& e) {
8448       {
8449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8450       };
8451     } catch (std::exception& e) {
8452       {
8453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8454       };
8455     } catch (...) {
8456       {
8457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8458       };
8459     }
8460   }
8461   jresult = result;
8462   return jresult;
8463 }
8464
8465
8466 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
8467   unsigned int jresult ;
8468   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8469   Dali::Uint16Pair *arg2 = 0 ;
8470   bool result;
8471
8472   arg1 = (Dali::Uint16Pair *)jarg1;
8473   arg2 = (Dali::Uint16Pair *)jarg2;
8474   if (!arg2) {
8475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8476     return 0;
8477   }
8478   {
8479     try {
8480       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
8481     } catch (std::out_of_range& e) {
8482       {
8483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8484       };
8485     } catch (std::exception& e) {
8486       {
8487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8488       };
8489     } catch (...) {
8490       {
8491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8492       };
8493     }
8494   }
8495   jresult = result;
8496   return jresult;
8497 }
8498
8499
8500 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
8501   unsigned int jresult ;
8502   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8503   Dali::Uint16Pair *arg2 = 0 ;
8504   bool result;
8505
8506   arg1 = (Dali::Uint16Pair *)jarg1;
8507   arg2 = (Dali::Uint16Pair *)jarg2;
8508   if (!arg2) {
8509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8510     return 0;
8511   }
8512   {
8513     try {
8514       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
8515     } catch (std::out_of_range& e) {
8516       {
8517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8518       };
8519     } catch (std::exception& e) {
8520       {
8521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8522       };
8523     } catch (...) {
8524       {
8525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8526       };
8527     }
8528   }
8529   jresult = result;
8530   return jresult;
8531 }
8532
8533
8534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
8535   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8536
8537   arg1 = (Dali::Uint16Pair *)jarg1;
8538   {
8539     try {
8540       delete arg1;
8541     } catch (std::out_of_range& e) {
8542       {
8543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8544       };
8545     } catch (std::exception& e) {
8546       {
8547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8548       };
8549     } catch (...) {
8550       {
8551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8552       };
8553     }
8554   }
8555 }
8556
8557
8558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
8559   void * jresult ;
8560   Dali::Degree *result = 0 ;
8561
8562   {
8563     try {
8564       result = (Dali::Degree *)new Dali::Degree();
8565     } catch (std::out_of_range& e) {
8566       {
8567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8568       };
8569     } catch (std::exception& e) {
8570       {
8571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8572       };
8573     } catch (...) {
8574       {
8575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8576       };
8577     }
8578   }
8579   jresult = (void *)result;
8580   return jresult;
8581 }
8582
8583
8584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
8585   void * jresult ;
8586   float arg1 ;
8587   Dali::Degree *result = 0 ;
8588
8589   arg1 = (float)jarg1;
8590   {
8591     try {
8592       result = (Dali::Degree *)new Dali::Degree(arg1);
8593     } catch (std::out_of_range& e) {
8594       {
8595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8596       };
8597     } catch (std::exception& e) {
8598       {
8599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8600       };
8601     } catch (...) {
8602       {
8603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8604       };
8605     }
8606   }
8607   jresult = (void *)result;
8608   return jresult;
8609 }
8610
8611
8612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
8613   void * jresult ;
8614   Dali::Radian arg1 ;
8615   Dali::Radian *argp1 ;
8616   Dali::Degree *result = 0 ;
8617
8618   argp1 = (Dali::Radian *)jarg1;
8619   if (!argp1) {
8620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8621     return 0;
8622   }
8623   arg1 = *argp1;
8624   {
8625     try {
8626       result = (Dali::Degree *)new Dali::Degree(arg1);
8627     } catch (std::out_of_range& e) {
8628       {
8629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8630       };
8631     } catch (std::exception& e) {
8632       {
8633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8634       };
8635     } catch (...) {
8636       {
8637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8638       };
8639     }
8640   }
8641   jresult = (void *)result;
8642   return jresult;
8643 }
8644
8645
8646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
8647   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8648   float arg2 ;
8649
8650   arg1 = (Dali::Degree *)jarg1;
8651   arg2 = (float)jarg2;
8652   if (arg1) (arg1)->degree = arg2;
8653 }
8654
8655
8656 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
8657   float jresult ;
8658   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8659   float result;
8660
8661   arg1 = (Dali::Degree *)jarg1;
8662   result = (float) ((arg1)->degree);
8663   jresult = result;
8664   return jresult;
8665 }
8666
8667
8668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
8669   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8670
8671   arg1 = (Dali::Degree *)jarg1;
8672   {
8673     try {
8674       delete arg1;
8675     } catch (std::out_of_range& e) {
8676       {
8677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8678       };
8679     } catch (std::exception& e) {
8680       {
8681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8682       };
8683     } catch (...) {
8684       {
8685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8686       };
8687     }
8688   }
8689 }
8690
8691
8692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
8693   void * jresult ;
8694   Dali::Radian *result = 0 ;
8695
8696   result = (Dali::Radian *)&Dali::ANGLE_360;
8697   jresult = (void *)result;
8698   return jresult;
8699 }
8700
8701
8702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
8703   void * jresult ;
8704   Dali::Radian *result = 0 ;
8705
8706   result = (Dali::Radian *)&Dali::ANGLE_315;
8707   jresult = (void *)result;
8708   return jresult;
8709 }
8710
8711
8712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
8713   void * jresult ;
8714   Dali::Radian *result = 0 ;
8715
8716   result = (Dali::Radian *)&Dali::ANGLE_270;
8717   jresult = (void *)result;
8718   return jresult;
8719 }
8720
8721
8722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
8723   void * jresult ;
8724   Dali::Radian *result = 0 ;
8725
8726   result = (Dali::Radian *)&Dali::ANGLE_225;
8727   jresult = (void *)result;
8728   return jresult;
8729 }
8730
8731
8732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
8733   void * jresult ;
8734   Dali::Radian *result = 0 ;
8735
8736   result = (Dali::Radian *)&Dali::ANGLE_180;
8737   jresult = (void *)result;
8738   return jresult;
8739 }
8740
8741
8742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
8743   void * jresult ;
8744   Dali::Radian *result = 0 ;
8745
8746   result = (Dali::Radian *)&Dali::ANGLE_135;
8747   jresult = (void *)result;
8748   return jresult;
8749 }
8750
8751
8752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
8753   void * jresult ;
8754   Dali::Radian *result = 0 ;
8755
8756   result = (Dali::Radian *)&Dali::ANGLE_120;
8757   jresult = (void *)result;
8758   return jresult;
8759 }
8760
8761
8762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
8763   void * jresult ;
8764   Dali::Radian *result = 0 ;
8765
8766   result = (Dali::Radian *)&Dali::ANGLE_90;
8767   jresult = (void *)result;
8768   return jresult;
8769 }
8770
8771
8772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
8773   void * jresult ;
8774   Dali::Radian *result = 0 ;
8775
8776   result = (Dali::Radian *)&Dali::ANGLE_60;
8777   jresult = (void *)result;
8778   return jresult;
8779 }
8780
8781
8782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
8783   void * jresult ;
8784   Dali::Radian *result = 0 ;
8785
8786   result = (Dali::Radian *)&Dali::ANGLE_45;
8787   jresult = (void *)result;
8788   return jresult;
8789 }
8790
8791
8792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
8793   void * jresult ;
8794   Dali::Radian *result = 0 ;
8795
8796   result = (Dali::Radian *)&Dali::ANGLE_30;
8797   jresult = (void *)result;
8798   return jresult;
8799 }
8800
8801
8802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
8803   void * jresult ;
8804   Dali::Radian *result = 0 ;
8805
8806   result = (Dali::Radian *)&Dali::ANGLE_0;
8807   jresult = (void *)result;
8808   return jresult;
8809 }
8810
8811
8812 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
8813   unsigned int jresult ;
8814   Dali::Degree *arg1 = 0 ;
8815   Dali::Degree *arg2 = 0 ;
8816   bool result;
8817
8818   arg1 = (Dali::Degree *)jarg1;
8819   if (!arg1) {
8820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8821     return 0;
8822   }
8823   arg2 = (Dali::Degree *)jarg2;
8824   if (!arg2) {
8825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8826     return 0;
8827   }
8828   {
8829     try {
8830       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8831     } catch (std::out_of_range& e) {
8832       {
8833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8834       };
8835     } catch (std::exception& e) {
8836       {
8837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8838       };
8839     } catch (...) {
8840       {
8841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8842       };
8843     }
8844   }
8845   jresult = result;
8846   return jresult;
8847 }
8848
8849
8850 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
8851   unsigned int jresult ;
8852   Dali::Degree *arg1 = 0 ;
8853   Dali::Degree *arg2 = 0 ;
8854   bool result;
8855
8856   arg1 = (Dali::Degree *)jarg1;
8857   if (!arg1) {
8858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8859     return 0;
8860   }
8861   arg2 = (Dali::Degree *)jarg2;
8862   if (!arg2) {
8863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8864     return 0;
8865   }
8866   {
8867     try {
8868       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8869     } catch (std::out_of_range& e) {
8870       {
8871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8872       };
8873     } catch (std::exception& e) {
8874       {
8875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8876       };
8877     } catch (...) {
8878       {
8879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8880       };
8881     }
8882   }
8883   jresult = result;
8884   return jresult;
8885 }
8886
8887
8888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
8889   void * jresult ;
8890   Dali::Degree arg1 ;
8891   float arg2 ;
8892   float arg3 ;
8893   Dali::Degree *argp1 ;
8894   Dali::Degree result;
8895
8896   argp1 = (Dali::Degree *)jarg1;
8897   if (!argp1) {
8898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8899     return 0;
8900   }
8901   arg1 = *argp1;
8902   arg2 = (float)jarg2;
8903   arg3 = (float)jarg3;
8904   {
8905     try {
8906       result = Dali::Clamp(arg1,arg2,arg3);
8907     } catch (std::out_of_range& e) {
8908       {
8909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8910       };
8911     } catch (std::exception& e) {
8912       {
8913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8914       };
8915     } catch (...) {
8916       {
8917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8918       };
8919     }
8920   }
8921   jresult = new Dali::Degree((const Dali::Degree &)result);
8922   return jresult;
8923 }
8924
8925
8926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
8927   void * jresult ;
8928   Dali::Radian *result = 0 ;
8929
8930   {
8931     try {
8932       result = (Dali::Radian *)new Dali::Radian();
8933     } catch (std::out_of_range& e) {
8934       {
8935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8936       };
8937     } catch (std::exception& e) {
8938       {
8939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8940       };
8941     } catch (...) {
8942       {
8943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8944       };
8945     }
8946   }
8947   jresult = (void *)result;
8948   return jresult;
8949 }
8950
8951
8952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
8953   void * jresult ;
8954   float arg1 ;
8955   Dali::Radian *result = 0 ;
8956
8957   arg1 = (float)jarg1;
8958   {
8959     try {
8960       result = (Dali::Radian *)new Dali::Radian(arg1);
8961     } catch (std::out_of_range& e) {
8962       {
8963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8964       };
8965     } catch (std::exception& e) {
8966       {
8967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8968       };
8969     } catch (...) {
8970       {
8971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8972       };
8973     }
8974   }
8975   jresult = (void *)result;
8976   return jresult;
8977 }
8978
8979
8980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
8981   void * jresult ;
8982   Dali::Degree arg1 ;
8983   Dali::Degree *argp1 ;
8984   Dali::Radian *result = 0 ;
8985
8986   argp1 = (Dali::Degree *)jarg1;
8987   if (!argp1) {
8988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8989     return 0;
8990   }
8991   arg1 = *argp1;
8992   {
8993     try {
8994       result = (Dali::Radian *)new Dali::Radian(arg1);
8995     } catch (std::out_of_range& e) {
8996       {
8997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8998       };
8999     } catch (std::exception& e) {
9000       {
9001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9002       };
9003     } catch (...) {
9004       {
9005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9006       };
9007     }
9008   }
9009   jresult = (void *)result;
9010   return jresult;
9011 }
9012
9013
9014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
9015   void * jresult ;
9016   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9017   float arg2 ;
9018   Dali::Radian *result = 0 ;
9019
9020   arg1 = (Dali::Radian *)jarg1;
9021   arg2 = (float)jarg2;
9022   {
9023     try {
9024       result = (Dali::Radian *) &(arg1)->operator =(arg2);
9025     } catch (std::out_of_range& e) {
9026       {
9027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9028       };
9029     } catch (std::exception& e) {
9030       {
9031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9032       };
9033     } catch (...) {
9034       {
9035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9036       };
9037     }
9038   }
9039   jresult = (void *)result;
9040   return jresult;
9041 }
9042
9043
9044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
9045   void * jresult ;
9046   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9047   Dali::Degree arg2 ;
9048   Dali::Degree *argp2 ;
9049   Dali::Radian *result = 0 ;
9050
9051   arg1 = (Dali::Radian *)jarg1;
9052   argp2 = (Dali::Degree *)jarg2;
9053   if (!argp2) {
9054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9055     return 0;
9056   }
9057   arg2 = *argp2;
9058   {
9059     try {
9060       result = (Dali::Radian *) &(arg1)->operator =(arg2);
9061     } catch (std::out_of_range& e) {
9062       {
9063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9064       };
9065     } catch (std::exception& e) {
9066       {
9067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9068       };
9069     } catch (...) {
9070       {
9071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9072       };
9073     }
9074   }
9075   jresult = (void *)result;
9076   return jresult;
9077 }
9078
9079
9080 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
9081   float jresult ;
9082   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9083   float result;
9084
9085   arg1 = (Dali::Radian *)jarg1;
9086   {
9087     try {
9088       result = (float)((Dali::Radian const *)arg1)->operator float();
9089     } catch (std::out_of_range& e) {
9090       {
9091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9092       };
9093     } catch (std::exception& e) {
9094       {
9095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9096       };
9097     } catch (...) {
9098       {
9099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9100       };
9101     }
9102   }
9103   jresult = result;
9104   return jresult;
9105 }
9106
9107
9108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
9109   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9110   float arg2 ;
9111
9112   arg1 = (Dali::Radian *)jarg1;
9113   arg2 = (float)jarg2;
9114   if (arg1) (arg1)->radian = arg2;
9115 }
9116
9117
9118 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
9119   float jresult ;
9120   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9121   float result;
9122
9123   arg1 = (Dali::Radian *)jarg1;
9124   result = (float) ((arg1)->radian);
9125   jresult = result;
9126   return jresult;
9127 }
9128
9129
9130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
9131   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9132
9133   arg1 = (Dali::Radian *)jarg1;
9134   {
9135     try {
9136       delete arg1;
9137     } catch (std::out_of_range& e) {
9138       {
9139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9140       };
9141     } catch (std::exception& e) {
9142       {
9143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9144       };
9145     } catch (...) {
9146       {
9147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9148       };
9149     }
9150   }
9151 }
9152
9153
9154 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
9155   unsigned int jresult ;
9156   Dali::Radian arg1 ;
9157   Dali::Radian arg2 ;
9158   Dali::Radian *argp1 ;
9159   Dali::Radian *argp2 ;
9160   bool result;
9161
9162   argp1 = (Dali::Radian *)jarg1;
9163   if (!argp1) {
9164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9165     return 0;
9166   }
9167   arg1 = *argp1;
9168   argp2 = (Dali::Radian *)jarg2;
9169   if (!argp2) {
9170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9171     return 0;
9172   }
9173   arg2 = *argp2;
9174   {
9175     try {
9176       result = (bool)Dali::operator ==(arg1,arg2);
9177     } catch (std::out_of_range& e) {
9178       {
9179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9180       };
9181     } catch (std::exception& e) {
9182       {
9183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9184       };
9185     } catch (...) {
9186       {
9187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9188       };
9189     }
9190   }
9191   jresult = result;
9192   return jresult;
9193 }
9194
9195
9196 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
9197   unsigned int jresult ;
9198   Dali::Radian arg1 ;
9199   Dali::Radian arg2 ;
9200   Dali::Radian *argp1 ;
9201   Dali::Radian *argp2 ;
9202   bool result;
9203
9204   argp1 = (Dali::Radian *)jarg1;
9205   if (!argp1) {
9206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9207     return 0;
9208   }
9209   arg1 = *argp1;
9210   argp2 = (Dali::Radian *)jarg2;
9211   if (!argp2) {
9212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9213     return 0;
9214   }
9215   arg2 = *argp2;
9216   {
9217     try {
9218       result = (bool)Dali::operator !=(arg1,arg2);
9219     } catch (std::out_of_range& e) {
9220       {
9221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9222       };
9223     } catch (std::exception& e) {
9224       {
9225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9226       };
9227     } catch (...) {
9228       {
9229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9230       };
9231     }
9232   }
9233   jresult = result;
9234   return jresult;
9235 }
9236
9237
9238 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
9239   unsigned int jresult ;
9240   Dali::Radian arg1 ;
9241   Dali::Degree arg2 ;
9242   Dali::Radian *argp1 ;
9243   Dali::Degree *argp2 ;
9244   bool result;
9245
9246   argp1 = (Dali::Radian *)jarg1;
9247   if (!argp1) {
9248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9249     return 0;
9250   }
9251   arg1 = *argp1;
9252   argp2 = (Dali::Degree *)jarg2;
9253   if (!argp2) {
9254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9255     return 0;
9256   }
9257   arg2 = *argp2;
9258   {
9259     try {
9260       result = (bool)Dali::operator ==(arg1,arg2);
9261     } catch (std::out_of_range& e) {
9262       {
9263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9264       };
9265     } catch (std::exception& e) {
9266       {
9267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9268       };
9269     } catch (...) {
9270       {
9271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9272       };
9273     }
9274   }
9275   jresult = result;
9276   return jresult;
9277 }
9278
9279
9280 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
9281   unsigned int jresult ;
9282   Dali::Radian arg1 ;
9283   Dali::Degree arg2 ;
9284   Dali::Radian *argp1 ;
9285   Dali::Degree *argp2 ;
9286   bool result;
9287
9288   argp1 = (Dali::Radian *)jarg1;
9289   if (!argp1) {
9290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9291     return 0;
9292   }
9293   arg1 = *argp1;
9294   argp2 = (Dali::Degree *)jarg2;
9295   if (!argp2) {
9296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9297     return 0;
9298   }
9299   arg2 = *argp2;
9300   {
9301     try {
9302       result = (bool)Dali::operator !=(arg1,arg2);
9303     } catch (std::out_of_range& e) {
9304       {
9305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9306       };
9307     } catch (std::exception& e) {
9308       {
9309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9310       };
9311     } catch (...) {
9312       {
9313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9314       };
9315     }
9316   }
9317   jresult = result;
9318   return jresult;
9319 }
9320
9321
9322 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
9323   unsigned int jresult ;
9324   Dali::Degree arg1 ;
9325   Dali::Radian arg2 ;
9326   Dali::Degree *argp1 ;
9327   Dali::Radian *argp2 ;
9328   bool result;
9329
9330   argp1 = (Dali::Degree *)jarg1;
9331   if (!argp1) {
9332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9333     return 0;
9334   }
9335   arg1 = *argp1;
9336   argp2 = (Dali::Radian *)jarg2;
9337   if (!argp2) {
9338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9339     return 0;
9340   }
9341   arg2 = *argp2;
9342   {
9343     try {
9344       result = (bool)Dali::operator ==(arg1,arg2);
9345     } catch (std::out_of_range& e) {
9346       {
9347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9348       };
9349     } catch (std::exception& e) {
9350       {
9351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9352       };
9353     } catch (...) {
9354       {
9355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9356       };
9357     }
9358   }
9359   jresult = result;
9360   return jresult;
9361 }
9362
9363
9364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
9365   unsigned int jresult ;
9366   Dali::Degree arg1 ;
9367   Dali::Radian arg2 ;
9368   Dali::Degree *argp1 ;
9369   Dali::Radian *argp2 ;
9370   bool result;
9371
9372   argp1 = (Dali::Degree *)jarg1;
9373   if (!argp1) {
9374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9375     return 0;
9376   }
9377   arg1 = *argp1;
9378   argp2 = (Dali::Radian *)jarg2;
9379   if (!argp2) {
9380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9381     return 0;
9382   }
9383   arg2 = *argp2;
9384   {
9385     try {
9386       result = (bool)Dali::operator !=(arg1,arg2);
9387     } catch (std::out_of_range& e) {
9388       {
9389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9390       };
9391     } catch (std::exception& e) {
9392       {
9393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9394       };
9395     } catch (...) {
9396       {
9397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9398       };
9399     }
9400   }
9401   jresult = result;
9402   return jresult;
9403 }
9404
9405
9406 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
9407   unsigned int jresult ;
9408   Dali::Radian arg1 ;
9409   Dali::Radian arg2 ;
9410   Dali::Radian *argp1 ;
9411   Dali::Radian *argp2 ;
9412   bool result;
9413
9414   argp1 = (Dali::Radian *)jarg1;
9415   if (!argp1) {
9416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9417     return 0;
9418   }
9419   arg1 = *argp1;
9420   argp2 = (Dali::Radian *)jarg2;
9421   if (!argp2) {
9422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9423     return 0;
9424   }
9425   arg2 = *argp2;
9426   {
9427     try {
9428       result = (bool)Dali::operator >(arg1,arg2);
9429     } catch (std::out_of_range& e) {
9430       {
9431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9432       };
9433     } catch (std::exception& e) {
9434       {
9435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9436       };
9437     } catch (...) {
9438       {
9439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9440       };
9441     }
9442   }
9443   jresult = result;
9444   return jresult;
9445 }
9446
9447
9448 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
9449   unsigned int jresult ;
9450   Dali::Radian arg1 ;
9451   Dali::Degree arg2 ;
9452   Dali::Radian *argp1 ;
9453   Dali::Degree *argp2 ;
9454   bool result;
9455
9456   argp1 = (Dali::Radian *)jarg1;
9457   if (!argp1) {
9458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9459     return 0;
9460   }
9461   arg1 = *argp1;
9462   argp2 = (Dali::Degree *)jarg2;
9463   if (!argp2) {
9464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9465     return 0;
9466   }
9467   arg2 = *argp2;
9468   {
9469     try {
9470       result = (bool)Dali::operator >(arg1,arg2);
9471     } catch (std::out_of_range& e) {
9472       {
9473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9474       };
9475     } catch (std::exception& e) {
9476       {
9477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9478       };
9479     } catch (...) {
9480       {
9481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9482       };
9483     }
9484   }
9485   jresult = result;
9486   return jresult;
9487 }
9488
9489
9490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
9491   unsigned int jresult ;
9492   Dali::Degree arg1 ;
9493   Dali::Radian arg2 ;
9494   Dali::Degree *argp1 ;
9495   Dali::Radian *argp2 ;
9496   bool result;
9497
9498   argp1 = (Dali::Degree *)jarg1;
9499   if (!argp1) {
9500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9501     return 0;
9502   }
9503   arg1 = *argp1;
9504   argp2 = (Dali::Radian *)jarg2;
9505   if (!argp2) {
9506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9507     return 0;
9508   }
9509   arg2 = *argp2;
9510   {
9511     try {
9512       result = (bool)Dali::operator >(arg1,arg2);
9513     } catch (std::out_of_range& e) {
9514       {
9515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9516       };
9517     } catch (std::exception& e) {
9518       {
9519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9520       };
9521     } catch (...) {
9522       {
9523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9524       };
9525     }
9526   }
9527   jresult = result;
9528   return jresult;
9529 }
9530
9531
9532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
9533   unsigned int jresult ;
9534   Dali::Radian arg1 ;
9535   Dali::Radian arg2 ;
9536   Dali::Radian *argp1 ;
9537   Dali::Radian *argp2 ;
9538   bool result;
9539
9540   argp1 = (Dali::Radian *)jarg1;
9541   if (!argp1) {
9542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9543     return 0;
9544   }
9545   arg1 = *argp1;
9546   argp2 = (Dali::Radian *)jarg2;
9547   if (!argp2) {
9548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9549     return 0;
9550   }
9551   arg2 = *argp2;
9552   {
9553     try {
9554       result = (bool)Dali::operator <(arg1,arg2);
9555     } catch (std::out_of_range& e) {
9556       {
9557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9558       };
9559     } catch (std::exception& e) {
9560       {
9561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9562       };
9563     } catch (...) {
9564       {
9565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9566       };
9567     }
9568   }
9569   jresult = result;
9570   return jresult;
9571 }
9572
9573
9574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
9575   unsigned int jresult ;
9576   Dali::Radian arg1 ;
9577   Dali::Degree arg2 ;
9578   Dali::Radian *argp1 ;
9579   Dali::Degree *argp2 ;
9580   bool result;
9581
9582   argp1 = (Dali::Radian *)jarg1;
9583   if (!argp1) {
9584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9585     return 0;
9586   }
9587   arg1 = *argp1;
9588   argp2 = (Dali::Degree *)jarg2;
9589   if (!argp2) {
9590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9591     return 0;
9592   }
9593   arg2 = *argp2;
9594   {
9595     try {
9596       result = (bool)Dali::operator <(arg1,arg2);
9597     } catch (std::out_of_range& e) {
9598       {
9599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9600       };
9601     } catch (std::exception& e) {
9602       {
9603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9604       };
9605     } catch (...) {
9606       {
9607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9608       };
9609     }
9610   }
9611   jresult = result;
9612   return jresult;
9613 }
9614
9615
9616 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
9617   unsigned int jresult ;
9618   Dali::Degree arg1 ;
9619   Dali::Radian arg2 ;
9620   Dali::Degree *argp1 ;
9621   Dali::Radian *argp2 ;
9622   bool result;
9623
9624   argp1 = (Dali::Degree *)jarg1;
9625   if (!argp1) {
9626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9627     return 0;
9628   }
9629   arg1 = *argp1;
9630   argp2 = (Dali::Radian *)jarg2;
9631   if (!argp2) {
9632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9633     return 0;
9634   }
9635   arg2 = *argp2;
9636   {
9637     try {
9638       result = (bool)Dali::operator <(arg1,arg2);
9639     } catch (std::out_of_range& e) {
9640       {
9641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9642       };
9643     } catch (std::exception& e) {
9644       {
9645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9646       };
9647     } catch (...) {
9648       {
9649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9650       };
9651     }
9652   }
9653   jresult = result;
9654   return jresult;
9655 }
9656
9657
9658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
9659   void * jresult ;
9660   Dali::Radian arg1 ;
9661   float arg2 ;
9662   Dali::Radian *argp1 ;
9663   Dali::Radian result;
9664
9665   argp1 = (Dali::Radian *)jarg1;
9666   if (!argp1) {
9667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9668     return 0;
9669   }
9670   arg1 = *argp1;
9671   arg2 = (float)jarg2;
9672   {
9673     try {
9674       result = Dali::operator *(arg1,arg2);
9675     } catch (std::out_of_range& e) {
9676       {
9677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9678       };
9679     } catch (std::exception& e) {
9680       {
9681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9682       };
9683     } catch (...) {
9684       {
9685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9686       };
9687     }
9688   }
9689   jresult = new Dali::Radian((const Dali::Radian &)result);
9690   return jresult;
9691 }
9692
9693
9694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
9695   void * jresult ;
9696   Dali::Radian arg1 ;
9697   Dali::Radian *argp1 ;
9698   Dali::Radian result;
9699
9700   argp1 = (Dali::Radian *)jarg1;
9701   if (!argp1) {
9702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9703     return 0;
9704   }
9705   arg1 = *argp1;
9706   {
9707     try {
9708       result = Dali::operator -(arg1);
9709     } catch (std::out_of_range& e) {
9710       {
9711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9712       };
9713     } catch (std::exception& e) {
9714       {
9715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9716       };
9717     } catch (...) {
9718       {
9719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9720       };
9721     }
9722   }
9723   jresult = new Dali::Radian((const Dali::Radian &)result);
9724   return jresult;
9725 }
9726
9727
9728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
9729   void * jresult ;
9730   Dali::Radian arg1 ;
9731   float arg2 ;
9732   float arg3 ;
9733   Dali::Radian *argp1 ;
9734   Dali::Radian result;
9735
9736   argp1 = (Dali::Radian *)jarg1;
9737   if (!argp1) {
9738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9739     return 0;
9740   }
9741   arg1 = *argp1;
9742   arg2 = (float)jarg2;
9743   arg3 = (float)jarg3;
9744   {
9745     try {
9746       result = Dali::Clamp(arg1,arg2,arg3);
9747     } catch (std::out_of_range& e) {
9748       {
9749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9750       };
9751     } catch (std::exception& e) {
9752       {
9753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9754       };
9755     } catch (...) {
9756       {
9757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9758       };
9759     }
9760   }
9761   jresult = new Dali::Radian((const Dali::Radian &)result);
9762   return jresult;
9763 }
9764
9765
9766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
9767   void * jresult ;
9768   Dali::Quaternion *result = 0 ;
9769
9770   {
9771     try {
9772       result = (Dali::Quaternion *)new Dali::Quaternion();
9773     } catch (std::out_of_range& e) {
9774       {
9775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9776       };
9777     } catch (std::exception& e) {
9778       {
9779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9780       };
9781     } catch (...) {
9782       {
9783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9784       };
9785     }
9786   }
9787   jresult = (void *)result;
9788   return jresult;
9789 }
9790
9791
9792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
9793   void * jresult ;
9794   Dali::Radian arg1 ;
9795   Dali::Vector3 *arg2 = 0 ;
9796   Dali::Radian *argp1 ;
9797   Dali::Quaternion *result = 0 ;
9798
9799   argp1 = (Dali::Radian *)jarg1;
9800   if (!argp1) {
9801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9802     return 0;
9803   }
9804   arg1 = *argp1;
9805   arg2 = (Dali::Vector3 *)jarg2;
9806   if (!arg2) {
9807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9808     return 0;
9809   }
9810   {
9811     try {
9812       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
9813     } catch (std::out_of_range& e) {
9814       {
9815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9816       };
9817     } catch (std::exception& e) {
9818       {
9819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9820       };
9821     } catch (...) {
9822       {
9823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9824       };
9825     }
9826   }
9827   jresult = (void *)result;
9828   return jresult;
9829 }
9830
9831
9832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
9833   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9834
9835   arg1 = (Dali::Quaternion *)jarg1;
9836   {
9837     try {
9838       delete arg1;
9839     } catch (std::out_of_range& e) {
9840       {
9841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9842       };
9843     } catch (std::exception& e) {
9844       {
9845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9846       };
9847     } catch (...) {
9848       {
9849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9850       };
9851     }
9852   }
9853 }
9854
9855
9856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
9857   void * jresult ;
9858   Dali::Quaternion *result = 0 ;
9859
9860   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
9861   jresult = (void *)result;
9862   return jresult;
9863 }
9864
9865
9866 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
9867   unsigned int jresult ;
9868   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9869   bool result;
9870
9871   arg1 = (Dali::Quaternion *)jarg1;
9872   {
9873     try {
9874       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
9875     } catch (std::out_of_range& e) {
9876       {
9877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9878       };
9879     } catch (std::exception& e) {
9880       {
9881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9882       };
9883     } catch (...) {
9884       {
9885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9886       };
9887     }
9888   }
9889   jresult = result;
9890   return jresult;
9891 }
9892
9893
9894 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
9895   unsigned int jresult ;
9896   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9897   Dali::Vector3 *arg2 = 0 ;
9898   Dali::Radian *arg3 = 0 ;
9899   bool result;
9900
9901   arg1 = (Dali::Quaternion *)jarg1;
9902   arg2 = (Dali::Vector3 *)jarg2;
9903   if (!arg2) {
9904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
9905     return 0;
9906   }
9907   arg3 = (Dali::Radian *)jarg3;
9908   if (!arg3) {
9909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
9910     return 0;
9911   }
9912   {
9913     try {
9914       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
9915     } catch (std::out_of_range& e) {
9916       {
9917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9918       };
9919     } catch (std::exception& e) {
9920       {
9921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9922       };
9923     } catch (...) {
9924       {
9925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9926       };
9927     }
9928   }
9929   jresult = result;
9930   return jresult;
9931 }
9932
9933
9934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
9935   void * jresult ;
9936   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9937   Dali::Quaternion *arg2 = 0 ;
9938   Dali::Quaternion result;
9939
9940   arg1 = (Dali::Quaternion *)jarg1;
9941   arg2 = (Dali::Quaternion *)jarg2;
9942   if (!arg2) {
9943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9944     return 0;
9945   }
9946   {
9947     try {
9948       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
9949     } catch (std::out_of_range& e) {
9950       {
9951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9952       };
9953     } catch (std::exception& e) {
9954       {
9955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9956       };
9957     } catch (...) {
9958       {
9959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9960       };
9961     }
9962   }
9963   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9964   return jresult;
9965 }
9966
9967
9968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
9969   void * jresult ;
9970   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9971   Dali::Quaternion *arg2 = 0 ;
9972   Dali::Quaternion result;
9973
9974   arg1 = (Dali::Quaternion *)jarg1;
9975   arg2 = (Dali::Quaternion *)jarg2;
9976   if (!arg2) {
9977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9978     return 0;
9979   }
9980   {
9981     try {
9982       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
9983     } catch (std::out_of_range& e) {
9984       {
9985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9986       };
9987     } catch (std::exception& e) {
9988       {
9989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9990       };
9991     } catch (...) {
9992       {
9993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9994       };
9995     }
9996   }
9997   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9998   return jresult;
9999 }
10000
10001
10002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
10003   void * jresult ;
10004   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10005   Dali::Quaternion *arg2 = 0 ;
10006   Dali::Quaternion result;
10007
10008   arg1 = (Dali::Quaternion *)jarg1;
10009   arg2 = (Dali::Quaternion *)jarg2;
10010   if (!arg2) {
10011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10012     return 0;
10013   }
10014   {
10015     try {
10016       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
10017     } catch (std::out_of_range& e) {
10018       {
10019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10020       };
10021     } catch (std::exception& e) {
10022       {
10023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10024       };
10025     } catch (...) {
10026       {
10027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10028       };
10029     }
10030   }
10031   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10032   return jresult;
10033 }
10034
10035
10036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
10037   void * jresult ;
10038   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10039   Dali::Vector3 *arg2 = 0 ;
10040   Dali::Vector3 result;
10041
10042   arg1 = (Dali::Quaternion *)jarg1;
10043   arg2 = (Dali::Vector3 *)jarg2;
10044   if (!arg2) {
10045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10046     return 0;
10047   }
10048   {
10049     try {
10050       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
10051     } catch (std::out_of_range& e) {
10052       {
10053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10054       };
10055     } catch (std::exception& e) {
10056       {
10057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10058       };
10059     } catch (...) {
10060       {
10061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10062       };
10063     }
10064   }
10065   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
10066   return jresult;
10067 }
10068
10069
10070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
10071   void * jresult ;
10072   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10073   Dali::Quaternion *arg2 = 0 ;
10074   Dali::Quaternion result;
10075
10076   arg1 = (Dali::Quaternion *)jarg1;
10077   arg2 = (Dali::Quaternion *)jarg2;
10078   if (!arg2) {
10079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10080     return 0;
10081   }
10082   {
10083     try {
10084       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
10085     } catch (std::out_of_range& e) {
10086       {
10087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10088       };
10089     } catch (std::exception& e) {
10090       {
10091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10092       };
10093     } catch (...) {
10094       {
10095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10096       };
10097     }
10098   }
10099   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10100   return jresult;
10101 }
10102
10103
10104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
10105   void * jresult ;
10106   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10107   float arg2 ;
10108   Dali::Quaternion result;
10109
10110   arg1 = (Dali::Quaternion *)jarg1;
10111   arg2 = (float)jarg2;
10112   {
10113     try {
10114       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
10115     } catch (std::out_of_range& e) {
10116       {
10117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10118       };
10119     } catch (std::exception& e) {
10120       {
10121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10122       };
10123     } catch (...) {
10124       {
10125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10126       };
10127     }
10128   }
10129   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10130   return jresult;
10131 }
10132
10133
10134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
10135   void * jresult ;
10136   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10137   float arg2 ;
10138   Dali::Quaternion result;
10139
10140   arg1 = (Dali::Quaternion *)jarg1;
10141   arg2 = (float)jarg2;
10142   {
10143     try {
10144       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
10145     } catch (std::out_of_range& e) {
10146       {
10147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10148       };
10149     } catch (std::exception& e) {
10150       {
10151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10152       };
10153     } catch (...) {
10154       {
10155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10156       };
10157     }
10158   }
10159   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10160   return jresult;
10161 }
10162
10163
10164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
10165   void * jresult ;
10166   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10167   Dali::Quaternion result;
10168
10169   arg1 = (Dali::Quaternion *)jarg1;
10170   {
10171     try {
10172       result = ((Dali::Quaternion const *)arg1)->operator -();
10173     } catch (std::out_of_range& e) {
10174       {
10175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10176       };
10177     } catch (std::exception& e) {
10178       {
10179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10180       };
10181     } catch (...) {
10182       {
10183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10184       };
10185     }
10186   }
10187   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10188   return jresult;
10189 }
10190
10191
10192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
10193   void * jresult ;
10194   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10195   Dali::Quaternion *arg2 = 0 ;
10196   Dali::Quaternion *result = 0 ;
10197
10198   arg1 = (Dali::Quaternion *)jarg1;
10199   arg2 = (Dali::Quaternion *)jarg2;
10200   if (!arg2) {
10201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10202     return 0;
10203   }
10204   {
10205     try {
10206       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
10207     } catch (std::out_of_range& e) {
10208       {
10209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10210       };
10211     } catch (std::exception& e) {
10212       {
10213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10214       };
10215     } catch (...) {
10216       {
10217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10218       };
10219     }
10220   }
10221   jresult = (void *)result;
10222   return jresult;
10223 }
10224
10225
10226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
10227   void * jresult ;
10228   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10229   Dali::Quaternion *arg2 = 0 ;
10230   Dali::Quaternion *result = 0 ;
10231
10232   arg1 = (Dali::Quaternion *)jarg1;
10233   arg2 = (Dali::Quaternion *)jarg2;
10234   if (!arg2) {
10235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10236     return 0;
10237   }
10238   {
10239     try {
10240       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
10241     } catch (std::out_of_range& e) {
10242       {
10243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10244       };
10245     } catch (std::exception& e) {
10246       {
10247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10248       };
10249     } catch (...) {
10250       {
10251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10252       };
10253     }
10254   }
10255   jresult = (void *)result;
10256   return jresult;
10257 }
10258
10259
10260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
10261   void * jresult ;
10262   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10263   Dali::Quaternion *arg2 = 0 ;
10264   Dali::Quaternion *result = 0 ;
10265
10266   arg1 = (Dali::Quaternion *)jarg1;
10267   arg2 = (Dali::Quaternion *)jarg2;
10268   if (!arg2) {
10269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10270     return 0;
10271   }
10272   {
10273     try {
10274       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
10275     } catch (std::out_of_range& e) {
10276       {
10277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10278       };
10279     } catch (std::exception& e) {
10280       {
10281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10282       };
10283     } catch (...) {
10284       {
10285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10286       };
10287     }
10288   }
10289   jresult = (void *)result;
10290   return jresult;
10291 }
10292
10293
10294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
10295   void * jresult ;
10296   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10297   float arg2 ;
10298   Dali::Quaternion *result = 0 ;
10299
10300   arg1 = (Dali::Quaternion *)jarg1;
10301   arg2 = (float)jarg2;
10302   {
10303     try {
10304       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
10305     } catch (std::out_of_range& e) {
10306       {
10307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10308       };
10309     } catch (std::exception& e) {
10310       {
10311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10312       };
10313     } catch (...) {
10314       {
10315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10316       };
10317     }
10318   }
10319   jresult = (void *)result;
10320   return jresult;
10321 }
10322
10323
10324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
10325   void * jresult ;
10326   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10327   float arg2 ;
10328   Dali::Quaternion *result = 0 ;
10329
10330   arg1 = (Dali::Quaternion *)jarg1;
10331   arg2 = (float)jarg2;
10332   {
10333     try {
10334       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
10335     } catch (std::out_of_range& e) {
10336       {
10337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10338       };
10339     } catch (std::exception& e) {
10340       {
10341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10342       };
10343     } catch (...) {
10344       {
10345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10346       };
10347     }
10348   }
10349   jresult = (void *)result;
10350   return jresult;
10351 }
10352
10353
10354 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
10355   unsigned int jresult ;
10356   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10357   Dali::Quaternion *arg2 = 0 ;
10358   bool result;
10359
10360   arg1 = (Dali::Quaternion *)jarg1;
10361   arg2 = (Dali::Quaternion *)jarg2;
10362   if (!arg2) {
10363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10364     return 0;
10365   }
10366   {
10367     try {
10368       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
10369     } catch (std::out_of_range& e) {
10370       {
10371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10372       };
10373     } catch (std::exception& e) {
10374       {
10375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10376       };
10377     } catch (...) {
10378       {
10379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10380       };
10381     }
10382   }
10383   jresult = result;
10384   return jresult;
10385 }
10386
10387
10388 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
10389   unsigned int jresult ;
10390   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10391   Dali::Quaternion *arg2 = 0 ;
10392   bool result;
10393
10394   arg1 = (Dali::Quaternion *)jarg1;
10395   arg2 = (Dali::Quaternion *)jarg2;
10396   if (!arg2) {
10397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10398     return 0;
10399   }
10400   {
10401     try {
10402       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
10403     } catch (std::out_of_range& e) {
10404       {
10405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10406       };
10407     } catch (std::exception& e) {
10408       {
10409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10410       };
10411     } catch (...) {
10412       {
10413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10414       };
10415     }
10416   }
10417   jresult = result;
10418   return jresult;
10419 }
10420
10421
10422 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
10423   float jresult ;
10424   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10425   float result;
10426
10427   arg1 = (Dali::Quaternion *)jarg1;
10428   {
10429     try {
10430       result = (float)((Dali::Quaternion const *)arg1)->Length();
10431     } catch (std::out_of_range& e) {
10432       {
10433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10434       };
10435     } catch (std::exception& e) {
10436       {
10437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10438       };
10439     } catch (...) {
10440       {
10441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10442       };
10443     }
10444   }
10445   jresult = result;
10446   return jresult;
10447 }
10448
10449
10450 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
10451   float jresult ;
10452   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10453   float result;
10454
10455   arg1 = (Dali::Quaternion *)jarg1;
10456   {
10457     try {
10458       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
10459     } catch (std::out_of_range& e) {
10460       {
10461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10462       };
10463     } catch (std::exception& e) {
10464       {
10465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10466       };
10467     } catch (...) {
10468       {
10469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10470       };
10471     }
10472   }
10473   jresult = result;
10474   return jresult;
10475 }
10476
10477
10478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
10479   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10480
10481   arg1 = (Dali::Quaternion *)jarg1;
10482   {
10483     try {
10484       (arg1)->Normalize();
10485     } catch (std::out_of_range& e) {
10486       {
10487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10488       };
10489     } catch (std::exception& e) {
10490       {
10491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10492       };
10493     } catch (...) {
10494       {
10495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10496       };
10497     }
10498   }
10499 }
10500
10501
10502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
10503   void * jresult ;
10504   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10505   Dali::Quaternion result;
10506
10507   arg1 = (Dali::Quaternion *)jarg1;
10508   {
10509     try {
10510       result = ((Dali::Quaternion const *)arg1)->Normalized();
10511     } catch (std::out_of_range& e) {
10512       {
10513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10514       };
10515     } catch (std::exception& e) {
10516       {
10517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10518       };
10519     } catch (...) {
10520       {
10521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10522       };
10523     }
10524   }
10525   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10526   return jresult;
10527 }
10528
10529
10530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
10531   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10532
10533   arg1 = (Dali::Quaternion *)jarg1;
10534   {
10535     try {
10536       (arg1)->Conjugate();
10537     } catch (std::out_of_range& e) {
10538       {
10539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10540       };
10541     } catch (std::exception& e) {
10542       {
10543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10544       };
10545     } catch (...) {
10546       {
10547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10548       };
10549     }
10550   }
10551 }
10552
10553
10554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
10555   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10556
10557   arg1 = (Dali::Quaternion *)jarg1;
10558   {
10559     try {
10560       (arg1)->Invert();
10561     } catch (std::out_of_range& e) {
10562       {
10563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10564       };
10565     } catch (std::exception& e) {
10566       {
10567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10568       };
10569     } catch (...) {
10570       {
10571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10572       };
10573     }
10574   }
10575 }
10576
10577
10578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
10579   void * jresult ;
10580   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10581   Dali::Quaternion result;
10582
10583   arg1 = (Dali::Quaternion *)jarg1;
10584   {
10585     try {
10586       result = ((Dali::Quaternion const *)arg1)->Log();
10587     } catch (std::out_of_range& e) {
10588       {
10589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10590       };
10591     } catch (std::exception& e) {
10592       {
10593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10594       };
10595     } catch (...) {
10596       {
10597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10598       };
10599     }
10600   }
10601   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10602   return jresult;
10603 }
10604
10605
10606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
10607   void * jresult ;
10608   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10609   Dali::Quaternion result;
10610
10611   arg1 = (Dali::Quaternion *)jarg1;
10612   {
10613     try {
10614       result = ((Dali::Quaternion const *)arg1)->Exp();
10615     } catch (std::out_of_range& e) {
10616       {
10617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10618       };
10619     } catch (std::exception& e) {
10620       {
10621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10622       };
10623     } catch (...) {
10624       {
10625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10626       };
10627     }
10628   }
10629   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10630   return jresult;
10631 }
10632
10633
10634 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
10635   float jresult ;
10636   Dali::Quaternion *arg1 = 0 ;
10637   Dali::Quaternion *arg2 = 0 ;
10638   float result;
10639
10640   arg1 = (Dali::Quaternion *)jarg1;
10641   if (!arg1) {
10642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10643     return 0;
10644   }
10645   arg2 = (Dali::Quaternion *)jarg2;
10646   if (!arg2) {
10647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10648     return 0;
10649   }
10650   {
10651     try {
10652       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10653     } catch (std::out_of_range& e) {
10654       {
10655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10656       };
10657     } catch (std::exception& e) {
10658       {
10659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10660       };
10661     } catch (...) {
10662       {
10663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10664       };
10665     }
10666   }
10667   jresult = result;
10668   return jresult;
10669 }
10670
10671
10672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
10673   void * jresult ;
10674   Dali::Quaternion *arg1 = 0 ;
10675   Dali::Quaternion *arg2 = 0 ;
10676   float arg3 ;
10677   Dali::Quaternion result;
10678
10679   arg1 = (Dali::Quaternion *)jarg1;
10680   if (!arg1) {
10681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10682     return 0;
10683   }
10684   arg2 = (Dali::Quaternion *)jarg2;
10685   if (!arg2) {
10686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10687     return 0;
10688   }
10689   arg3 = (float)jarg3;
10690   {
10691     try {
10692       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10693     } catch (std::out_of_range& e) {
10694       {
10695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10696       };
10697     } catch (std::exception& e) {
10698       {
10699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10700       };
10701     } catch (...) {
10702       {
10703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10704       };
10705     }
10706   }
10707   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10708   return jresult;
10709 }
10710
10711
10712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
10713   void * jresult ;
10714   Dali::Quaternion *arg1 = 0 ;
10715   Dali::Quaternion *arg2 = 0 ;
10716   float arg3 ;
10717   Dali::Quaternion result;
10718
10719   arg1 = (Dali::Quaternion *)jarg1;
10720   if (!arg1) {
10721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10722     return 0;
10723   }
10724   arg2 = (Dali::Quaternion *)jarg2;
10725   if (!arg2) {
10726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10727     return 0;
10728   }
10729   arg3 = (float)jarg3;
10730   {
10731     try {
10732       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10733     } catch (std::out_of_range& e) {
10734       {
10735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10736       };
10737     } catch (std::exception& e) {
10738       {
10739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10740       };
10741     } catch (...) {
10742       {
10743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10744       };
10745     }
10746   }
10747   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10748   return jresult;
10749 }
10750
10751
10752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
10753   void * jresult ;
10754   Dali::Quaternion *arg1 = 0 ;
10755   Dali::Quaternion *arg2 = 0 ;
10756   float arg3 ;
10757   Dali::Quaternion result;
10758
10759   arg1 = (Dali::Quaternion *)jarg1;
10760   if (!arg1) {
10761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10762     return 0;
10763   }
10764   arg2 = (Dali::Quaternion *)jarg2;
10765   if (!arg2) {
10766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10767     return 0;
10768   }
10769   arg3 = (float)jarg3;
10770   {
10771     try {
10772       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10773     } catch (std::out_of_range& e) {
10774       {
10775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10776       };
10777     } catch (std::exception& e) {
10778       {
10779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10780       };
10781     } catch (...) {
10782       {
10783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10784       };
10785     }
10786   }
10787   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10788   return jresult;
10789 }
10790
10791
10792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
10793   void * jresult ;
10794   Dali::Quaternion *arg1 = 0 ;
10795   Dali::Quaternion *arg2 = 0 ;
10796   Dali::Quaternion *arg3 = 0 ;
10797   Dali::Quaternion *arg4 = 0 ;
10798   float arg5 ;
10799   Dali::Quaternion result;
10800
10801   arg1 = (Dali::Quaternion *)jarg1;
10802   if (!arg1) {
10803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10804     return 0;
10805   }
10806   arg2 = (Dali::Quaternion *)jarg2;
10807   if (!arg2) {
10808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10809     return 0;
10810   }
10811   arg3 = (Dali::Quaternion *)jarg3;
10812   if (!arg3) {
10813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10814     return 0;
10815   }
10816   arg4 = (Dali::Quaternion *)jarg4;
10817   if (!arg4) {
10818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10819     return 0;
10820   }
10821   arg5 = (float)jarg5;
10822   {
10823     try {
10824       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
10825     } catch (std::out_of_range& e) {
10826       {
10827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10828       };
10829     } catch (std::exception& e) {
10830       {
10831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10832       };
10833     } catch (...) {
10834       {
10835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10836       };
10837     }
10838   }
10839   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10840   return jresult;
10841 }
10842
10843
10844 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
10845   float jresult ;
10846   Dali::Quaternion *arg1 = 0 ;
10847   Dali::Quaternion *arg2 = 0 ;
10848   float result;
10849
10850   arg1 = (Dali::Quaternion *)jarg1;
10851   if (!arg1) {
10852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10853     return 0;
10854   }
10855   arg2 = (Dali::Quaternion *)jarg2;
10856   if (!arg2) {
10857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10858     return 0;
10859   }
10860   {
10861     try {
10862       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10863     } catch (std::out_of_range& e) {
10864       {
10865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10866       };
10867     } catch (std::exception& e) {
10868       {
10869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10870       };
10871     } catch (...) {
10872       {
10873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10874       };
10875     }
10876   }
10877   jresult = result;
10878   return jresult;
10879 }
10880
10881
10882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
10883   void * jresult ;
10884   Dali::Matrix *result = 0 ;
10885
10886   {
10887     try {
10888       result = (Dali::Matrix *)new Dali::Matrix();
10889     } catch (std::out_of_range& e) {
10890       {
10891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10892       };
10893     } catch (std::exception& e) {
10894       {
10895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10896       };
10897     } catch (...) {
10898       {
10899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10900       };
10901     }
10902   }
10903   jresult = (void *)result;
10904   return jresult;
10905 }
10906
10907
10908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
10909   void * jresult ;
10910   bool arg1 ;
10911   Dali::Matrix *result = 0 ;
10912
10913   arg1 = jarg1 ? true : false;
10914   {
10915     try {
10916       result = (Dali::Matrix *)new Dali::Matrix(arg1);
10917     } catch (std::out_of_range& e) {
10918       {
10919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10920       };
10921     } catch (std::exception& e) {
10922       {
10923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10924       };
10925     } catch (...) {
10926       {
10927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10928       };
10929     }
10930   }
10931   jresult = (void *)result;
10932   return jresult;
10933 }
10934
10935
10936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
10937   void * jresult ;
10938   float *arg1 = (float *) 0 ;
10939   Dali::Matrix *result = 0 ;
10940
10941   arg1 = jarg1;
10942   {
10943     try {
10944       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
10945     } catch (std::out_of_range& e) {
10946       {
10947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10948       };
10949     } catch (std::exception& e) {
10950       {
10951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10952       };
10953     } catch (...) {
10954       {
10955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10956       };
10957     }
10958   }
10959   jresult = (void *)result;
10960
10961
10962   return jresult;
10963 }
10964
10965
10966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
10967   void * jresult ;
10968   Dali::Quaternion *arg1 = 0 ;
10969   Dali::Matrix *result = 0 ;
10970
10971   arg1 = (Dali::Quaternion *)jarg1;
10972   if (!arg1) {
10973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10974     return 0;
10975   }
10976   {
10977     try {
10978       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
10979     } catch (std::out_of_range& e) {
10980       {
10981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10982       };
10983     } catch (std::exception& e) {
10984       {
10985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10986       };
10987     } catch (...) {
10988       {
10989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10990       };
10991     }
10992   }
10993   jresult = (void *)result;
10994   return jresult;
10995 }
10996
10997
10998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
10999   void * jresult ;
11000   Dali::Matrix *arg1 = 0 ;
11001   Dali::Matrix *result = 0 ;
11002
11003   arg1 = (Dali::Matrix *)jarg1;
11004   if (!arg1) {
11005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11006     return 0;
11007   }
11008   {
11009     try {
11010       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
11011     } catch (std::out_of_range& e) {
11012       {
11013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11014       };
11015     } catch (std::exception& e) {
11016       {
11017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11018       };
11019     } catch (...) {
11020       {
11021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11022       };
11023     }
11024   }
11025   jresult = (void *)result;
11026   return jresult;
11027 }
11028
11029
11030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
11031   void * jresult ;
11032   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11033   Dali::Matrix *arg2 = 0 ;
11034   Dali::Matrix *result = 0 ;
11035
11036   arg1 = (Dali::Matrix *)jarg1;
11037   arg2 = (Dali::Matrix *)jarg2;
11038   if (!arg2) {
11039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11040     return 0;
11041   }
11042   {
11043     try {
11044       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
11045     } catch (std::out_of_range& e) {
11046       {
11047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11048       };
11049     } catch (std::exception& e) {
11050       {
11051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11052       };
11053     } catch (...) {
11054       {
11055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11056       };
11057     }
11058   }
11059   jresult = (void *)result;
11060   return jresult;
11061 }
11062
11063
11064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
11065   void * jresult ;
11066   Dali::Matrix *result = 0 ;
11067
11068   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
11069   jresult = (void *)result;
11070   return jresult;
11071 }
11072
11073
11074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
11075   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11076
11077   arg1 = (Dali::Matrix *)jarg1;
11078   {
11079     try {
11080       (arg1)->SetIdentity();
11081     } catch (std::out_of_range& e) {
11082       {
11083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11084       };
11085     } catch (std::exception& e) {
11086       {
11087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11088       };
11089     } catch (...) {
11090       {
11091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11092       };
11093     }
11094   }
11095 }
11096
11097
11098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
11099   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11100   Dali::Vector3 *arg2 = 0 ;
11101
11102   arg1 = (Dali::Matrix *)jarg1;
11103   arg2 = (Dali::Vector3 *)jarg2;
11104   if (!arg2) {
11105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11106     return ;
11107   }
11108   {
11109     try {
11110       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
11111     } catch (std::out_of_range& e) {
11112       {
11113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11114       };
11115     } catch (std::exception& e) {
11116       {
11117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11118       };
11119     } catch (...) {
11120       {
11121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11122       };
11123     }
11124   }
11125 }
11126
11127
11128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
11129   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11130   Dali::Matrix *arg2 = 0 ;
11131
11132   arg1 = (Dali::Matrix *)jarg1;
11133   arg2 = (Dali::Matrix *)jarg2;
11134   if (!arg2) {
11135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11136     return ;
11137   }
11138   {
11139     try {
11140       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
11141     } catch (std::out_of_range& e) {
11142       {
11143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11144       };
11145     } catch (std::exception& e) {
11146       {
11147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11148       };
11149     } catch (...) {
11150       {
11151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11152       };
11153     }
11154   }
11155 }
11156
11157
11158 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
11159   unsigned int jresult ;
11160   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11161   bool result;
11162
11163   arg1 = (Dali::Matrix *)jarg1;
11164   {
11165     try {
11166       result = (bool)(arg1)->Invert();
11167     } catch (std::out_of_range& e) {
11168       {
11169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11170       };
11171     } catch (std::exception& e) {
11172       {
11173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11174       };
11175     } catch (...) {
11176       {
11177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11178       };
11179     }
11180   }
11181   jresult = result;
11182   return jresult;
11183 }
11184
11185
11186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
11187   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11188
11189   arg1 = (Dali::Matrix *)jarg1;
11190   {
11191     try {
11192       (arg1)->Transpose();
11193     } catch (std::out_of_range& e) {
11194       {
11195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11196       };
11197     } catch (std::exception& e) {
11198       {
11199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11200       };
11201     } catch (...) {
11202       {
11203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11204       };
11205     }
11206   }
11207 }
11208
11209
11210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
11211   void * jresult ;
11212   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11213   Dali::Vector3 result;
11214
11215   arg1 = (Dali::Matrix *)jarg1;
11216   {
11217     try {
11218       result = ((Dali::Matrix const *)arg1)->GetXAxis();
11219     } catch (std::out_of_range& e) {
11220       {
11221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11222       };
11223     } catch (std::exception& e) {
11224       {
11225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11226       };
11227     } catch (...) {
11228       {
11229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11230       };
11231     }
11232   }
11233   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11234   return jresult;
11235 }
11236
11237
11238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
11239   void * jresult ;
11240   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11241   Dali::Vector3 result;
11242
11243   arg1 = (Dali::Matrix *)jarg1;
11244   {
11245     try {
11246       result = ((Dali::Matrix const *)arg1)->GetYAxis();
11247     } catch (std::out_of_range& e) {
11248       {
11249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11250       };
11251     } catch (std::exception& e) {
11252       {
11253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11254       };
11255     } catch (...) {
11256       {
11257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11258       };
11259     }
11260   }
11261   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11262   return jresult;
11263 }
11264
11265
11266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
11267   void * jresult ;
11268   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11269   Dali::Vector3 result;
11270
11271   arg1 = (Dali::Matrix *)jarg1;
11272   {
11273     try {
11274       result = ((Dali::Matrix const *)arg1)->GetZAxis();
11275     } catch (std::out_of_range& e) {
11276       {
11277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11278       };
11279     } catch (std::exception& e) {
11280       {
11281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11282       };
11283     } catch (...) {
11284       {
11285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11286       };
11287     }
11288   }
11289   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11290   return jresult;
11291 }
11292
11293
11294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
11295   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11296   Dali::Vector3 *arg2 = 0 ;
11297
11298   arg1 = (Dali::Matrix *)jarg1;
11299   arg2 = (Dali::Vector3 *)jarg2;
11300   if (!arg2) {
11301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11302     return ;
11303   }
11304   {
11305     try {
11306       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
11307     } catch (std::out_of_range& e) {
11308       {
11309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11310       };
11311     } catch (std::exception& e) {
11312       {
11313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11314       };
11315     } catch (...) {
11316       {
11317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11318       };
11319     }
11320   }
11321 }
11322
11323
11324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
11325   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11326   Dali::Vector3 *arg2 = 0 ;
11327
11328   arg1 = (Dali::Matrix *)jarg1;
11329   arg2 = (Dali::Vector3 *)jarg2;
11330   if (!arg2) {
11331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11332     return ;
11333   }
11334   {
11335     try {
11336       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
11337     } catch (std::out_of_range& e) {
11338       {
11339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11340       };
11341     } catch (std::exception& e) {
11342       {
11343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11344       };
11345     } catch (...) {
11346       {
11347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11348       };
11349     }
11350   }
11351 }
11352
11353
11354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
11355   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11356   Dali::Vector3 *arg2 = 0 ;
11357
11358   arg1 = (Dali::Matrix *)jarg1;
11359   arg2 = (Dali::Vector3 *)jarg2;
11360   if (!arg2) {
11361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11362     return ;
11363   }
11364   {
11365     try {
11366       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
11367     } catch (std::out_of_range& e) {
11368       {
11369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11370       };
11371     } catch (std::exception& e) {
11372       {
11373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11374       };
11375     } catch (...) {
11376       {
11377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11378       };
11379     }
11380   }
11381 }
11382
11383
11384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
11385   void * jresult ;
11386   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11387   Dali::Vector4 *result = 0 ;
11388
11389   arg1 = (Dali::Matrix *)jarg1;
11390   {
11391     try {
11392       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
11393     } catch (std::out_of_range& e) {
11394       {
11395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11396       };
11397     } catch (std::exception& e) {
11398       {
11399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11400       };
11401     } catch (...) {
11402       {
11403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11404       };
11405     }
11406   }
11407   jresult = (void *)result;
11408   return jresult;
11409 }
11410
11411
11412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
11413   void * jresult ;
11414   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11415   Dali::Vector3 *result = 0 ;
11416
11417   arg1 = (Dali::Matrix *)jarg1;
11418   {
11419     try {
11420       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
11421     } catch (std::out_of_range& e) {
11422       {
11423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11424       };
11425     } catch (std::exception& e) {
11426       {
11427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11428       };
11429     } catch (...) {
11430       {
11431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11432       };
11433     }
11434   }
11435   jresult = (void *)result;
11436   return jresult;
11437 }
11438
11439
11440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
11441   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11442   Dali::Vector4 *arg2 = 0 ;
11443
11444   arg1 = (Dali::Matrix *)jarg1;
11445   arg2 = (Dali::Vector4 *)jarg2;
11446   if (!arg2) {
11447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11448     return ;
11449   }
11450   {
11451     try {
11452       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
11453     } catch (std::out_of_range& e) {
11454       {
11455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11456       };
11457     } catch (std::exception& e) {
11458       {
11459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11460       };
11461     } catch (...) {
11462       {
11463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11464       };
11465     }
11466   }
11467 }
11468
11469
11470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
11471   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11472   Dali::Vector3 *arg2 = 0 ;
11473
11474   arg1 = (Dali::Matrix *)jarg1;
11475   arg2 = (Dali::Vector3 *)jarg2;
11476   if (!arg2) {
11477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11478     return ;
11479   }
11480   {
11481     try {
11482       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
11483     } catch (std::out_of_range& e) {
11484       {
11485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11486       };
11487     } catch (std::exception& e) {
11488       {
11489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11490       };
11491     } catch (...) {
11492       {
11493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11494       };
11495     }
11496   }
11497 }
11498
11499
11500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
11501   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11502
11503   arg1 = (Dali::Matrix *)jarg1;
11504   {
11505     try {
11506       (arg1)->OrthoNormalize();
11507     } catch (std::out_of_range& e) {
11508       {
11509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11510       };
11511     } catch (std::exception& e) {
11512       {
11513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11514       };
11515     } catch (...) {
11516       {
11517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11518       };
11519     }
11520   }
11521 }
11522
11523
11524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
11525   void * jresult ;
11526   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11527   float *result = 0 ;
11528
11529   arg1 = (Dali::Matrix *)jarg1;
11530   {
11531     try {
11532       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
11533     } catch (std::out_of_range& e) {
11534       {
11535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11536       };
11537     } catch (std::exception& e) {
11538       {
11539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11540       };
11541     } catch (...) {
11542       {
11543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11544       };
11545     }
11546   }
11547   jresult = (void *)result;
11548   return jresult;
11549 }
11550
11551
11552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
11553   Dali::Matrix *arg1 = 0 ;
11554   Dali::Matrix *arg2 = 0 ;
11555   Dali::Matrix *arg3 = 0 ;
11556
11557   arg1 = (Dali::Matrix *)jarg1;
11558   if (!arg1) {
11559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11560     return ;
11561   }
11562   arg2 = (Dali::Matrix *)jarg2;
11563   if (!arg2) {
11564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11565     return ;
11566   }
11567   arg3 = (Dali::Matrix *)jarg3;
11568   if (!arg3) {
11569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11570     return ;
11571   }
11572   {
11573     try {
11574       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
11575     } catch (std::out_of_range& e) {
11576       {
11577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11578       };
11579     } catch (std::exception& e) {
11580       {
11581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11582       };
11583     } catch (...) {
11584       {
11585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11586       };
11587     }
11588   }
11589 }
11590
11591
11592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
11593   Dali::Matrix *arg1 = 0 ;
11594   Dali::Matrix *arg2 = 0 ;
11595   Dali::Quaternion *arg3 = 0 ;
11596
11597   arg1 = (Dali::Matrix *)jarg1;
11598   if (!arg1) {
11599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11600     return ;
11601   }
11602   arg2 = (Dali::Matrix *)jarg2;
11603   if (!arg2) {
11604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11605     return ;
11606   }
11607   arg3 = (Dali::Quaternion *)jarg3;
11608   if (!arg3) {
11609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11610     return ;
11611   }
11612   {
11613     try {
11614       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
11615     } catch (std::out_of_range& e) {
11616       {
11617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11618       };
11619     } catch (std::exception& e) {
11620       {
11621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11622       };
11623     } catch (...) {
11624       {
11625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11626       };
11627     }
11628   }
11629 }
11630
11631
11632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
11633   void * jresult ;
11634   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11635   Dali::Vector4 *arg2 = 0 ;
11636   Dali::Vector4 result;
11637
11638   arg1 = (Dali::Matrix *)jarg1;
11639   arg2 = (Dali::Vector4 *)jarg2;
11640   if (!arg2) {
11641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11642     return 0;
11643   }
11644   {
11645     try {
11646       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
11647     } catch (std::out_of_range& e) {
11648       {
11649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11650       };
11651     } catch (std::exception& e) {
11652       {
11653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11654       };
11655     } catch (...) {
11656       {
11657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11658       };
11659     }
11660   }
11661   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
11662   return jresult;
11663 }
11664
11665
11666 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
11667   unsigned int jresult ;
11668   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11669   Dali::Matrix *arg2 = 0 ;
11670   bool result;
11671
11672   arg1 = (Dali::Matrix *)jarg1;
11673   arg2 = (Dali::Matrix *)jarg2;
11674   if (!arg2) {
11675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11676     return 0;
11677   }
11678   {
11679     try {
11680       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
11681     } catch (std::out_of_range& e) {
11682       {
11683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11684       };
11685     } catch (std::exception& e) {
11686       {
11687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11688       };
11689     } catch (...) {
11690       {
11691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11692       };
11693     }
11694   }
11695   jresult = result;
11696   return jresult;
11697 }
11698
11699
11700 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
11701   unsigned int jresult ;
11702   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11703   Dali::Matrix *arg2 = 0 ;
11704   bool result;
11705
11706   arg1 = (Dali::Matrix *)jarg1;
11707   arg2 = (Dali::Matrix *)jarg2;
11708   if (!arg2) {
11709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11710     return 0;
11711   }
11712   {
11713     try {
11714       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
11715     } catch (std::out_of_range& e) {
11716       {
11717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11718       };
11719     } catch (std::exception& e) {
11720       {
11721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11722       };
11723     } catch (...) {
11724       {
11725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11726       };
11727     }
11728   }
11729   jresult = result;
11730   return jresult;
11731 }
11732
11733
11734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11735   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11736   Dali::Vector3 *arg2 = 0 ;
11737   Dali::Quaternion *arg3 = 0 ;
11738   Dali::Vector3 *arg4 = 0 ;
11739
11740   arg1 = (Dali::Matrix *)jarg1;
11741   arg2 = (Dali::Vector3 *)jarg2;
11742   if (!arg2) {
11743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11744     return ;
11745   }
11746   arg3 = (Dali::Quaternion *)jarg3;
11747   if (!arg3) {
11748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11749     return ;
11750   }
11751   arg4 = (Dali::Vector3 *)jarg4;
11752   if (!arg4) {
11753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11754     return ;
11755   }
11756   {
11757     try {
11758       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11759     } catch (std::out_of_range& e) {
11760       {
11761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11762       };
11763     } catch (std::exception& e) {
11764       {
11765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11766       };
11767     } catch (...) {
11768       {
11769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11770       };
11771     }
11772   }
11773 }
11774
11775
11776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11777   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11778   Dali::Vector3 *arg2 = 0 ;
11779   Dali::Quaternion *arg3 = 0 ;
11780   Dali::Vector3 *arg4 = 0 ;
11781
11782   arg1 = (Dali::Matrix *)jarg1;
11783   arg2 = (Dali::Vector3 *)jarg2;
11784   if (!arg2) {
11785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11786     return ;
11787   }
11788   arg3 = (Dali::Quaternion *)jarg3;
11789   if (!arg3) {
11790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11791     return ;
11792   }
11793   arg4 = (Dali::Vector3 *)jarg4;
11794   if (!arg4) {
11795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11796     return ;
11797   }
11798   {
11799     try {
11800       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11801     } catch (std::out_of_range& e) {
11802       {
11803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11804       };
11805     } catch (std::exception& e) {
11806       {
11807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11808       };
11809     } catch (...) {
11810       {
11811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11812       };
11813     }
11814   }
11815 }
11816
11817
11818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
11819   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11820   Dali::Vector3 *arg2 = 0 ;
11821   Dali::Vector3 *arg3 = 0 ;
11822   Dali::Vector3 *arg4 = 0 ;
11823   Dali::Vector3 *arg5 = 0 ;
11824
11825   arg1 = (Dali::Matrix *)jarg1;
11826   arg2 = (Dali::Vector3 *)jarg2;
11827   if (!arg2) {
11828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11829     return ;
11830   }
11831   arg3 = (Dali::Vector3 *)jarg3;
11832   if (!arg3) {
11833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11834     return ;
11835   }
11836   arg4 = (Dali::Vector3 *)jarg4;
11837   if (!arg4) {
11838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11839     return ;
11840   }
11841   arg5 = (Dali::Vector3 *)jarg5;
11842   if (!arg5) {
11843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11844     return ;
11845   }
11846   {
11847     try {
11848       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
11849     } catch (std::out_of_range& e) {
11850       {
11851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11852       };
11853     } catch (std::exception& e) {
11854       {
11855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11856       };
11857     } catch (...) {
11858       {
11859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11860       };
11861     }
11862   }
11863 }
11864
11865
11866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11867   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11868   Dali::Vector3 *arg2 = 0 ;
11869   Dali::Quaternion *arg3 = 0 ;
11870   Dali::Vector3 *arg4 = 0 ;
11871
11872   arg1 = (Dali::Matrix *)jarg1;
11873   arg2 = (Dali::Vector3 *)jarg2;
11874   if (!arg2) {
11875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11876     return ;
11877   }
11878   arg3 = (Dali::Quaternion *)jarg3;
11879   if (!arg3) {
11880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
11881     return ;
11882   }
11883   arg4 = (Dali::Vector3 *)jarg4;
11884   if (!arg4) {
11885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11886     return ;
11887   }
11888   {
11889     try {
11890       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
11891     } catch (std::out_of_range& e) {
11892       {
11893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11894       };
11895     } catch (std::exception& e) {
11896       {
11897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11898       };
11899     } catch (...) {
11900       {
11901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11902       };
11903     }
11904   }
11905 }
11906
11907
11908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
11909   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11910
11911   arg1 = (Dali::Matrix *)jarg1;
11912   {
11913     try {
11914       delete arg1;
11915     } catch (std::out_of_range& e) {
11916       {
11917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11918       };
11919     } catch (std::exception& e) {
11920       {
11921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11922       };
11923     } catch (...) {
11924       {
11925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11926       };
11927     }
11928   }
11929 }
11930
11931
11932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
11933   void * jresult ;
11934   Dali::Matrix3 *result = 0 ;
11935
11936   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
11937   jresult = (void *)result;
11938   return jresult;
11939 }
11940
11941
11942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
11943   void * jresult ;
11944   Dali::Matrix3 *result = 0 ;
11945
11946   {
11947     try {
11948       result = (Dali::Matrix3 *)new Dali::Matrix3();
11949     } catch (std::out_of_range& e) {
11950       {
11951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11952       };
11953     } catch (std::exception& e) {
11954       {
11955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11956       };
11957     } catch (...) {
11958       {
11959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11960       };
11961     }
11962   }
11963   jresult = (void *)result;
11964   return jresult;
11965 }
11966
11967
11968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
11969   void * jresult ;
11970   Dali::Matrix3 *arg1 = 0 ;
11971   Dali::Matrix3 *result = 0 ;
11972
11973   arg1 = (Dali::Matrix3 *)jarg1;
11974   if (!arg1) {
11975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
11976     return 0;
11977   }
11978   {
11979     try {
11980       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
11981     } catch (std::out_of_range& e) {
11982       {
11983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11984       };
11985     } catch (std::exception& e) {
11986       {
11987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11988       };
11989     } catch (...) {
11990       {
11991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11992       };
11993     }
11994   }
11995   jresult = (void *)result;
11996   return jresult;
11997 }
11998
11999
12000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
12001   void * jresult ;
12002   Dali::Matrix *arg1 = 0 ;
12003   Dali::Matrix3 *result = 0 ;
12004
12005   arg1 = (Dali::Matrix *)jarg1;
12006   if (!arg1) {
12007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12008     return 0;
12009   }
12010   {
12011     try {
12012       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
12013     } catch (std::out_of_range& e) {
12014       {
12015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12016       };
12017     } catch (std::exception& e) {
12018       {
12019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12020       };
12021     } catch (...) {
12022       {
12023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12024       };
12025     }
12026   }
12027   jresult = (void *)result;
12028   return jresult;
12029 }
12030
12031
12032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_3(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7, float jarg8, float jarg9) {
12033   void * jresult ;
12034   float arg1 ;
12035   float arg2 ;
12036   float arg3 ;
12037   float arg4 ;
12038   float arg5 ;
12039   float arg6 ;
12040   float arg7 ;
12041   float arg8 ;
12042   float arg9 ;
12043   Dali::Matrix3 *result = 0 ;
12044
12045   arg1 = (float)jarg1;
12046   arg2 = (float)jarg2;
12047   arg3 = (float)jarg3;
12048   arg4 = (float)jarg4;
12049   arg5 = (float)jarg5;
12050   arg6 = (float)jarg6;
12051   arg7 = (float)jarg7;
12052   arg8 = (float)jarg8;
12053   arg9 = (float)jarg9;
12054   {
12055     try {
12056       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
12057     } catch (std::out_of_range& e) {
12058       {
12059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12060       };
12061     } catch (std::exception& e) {
12062       {
12063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12064       };
12065     } catch (...) {
12066       {
12067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12068       };
12069     }
12070   }
12071   jresult = (void *)result;
12072   return jresult;
12073 }
12074
12075
12076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
12077   void * jresult ;
12078   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12079   Dali::Matrix3 *arg2 = 0 ;
12080   Dali::Matrix3 *result = 0 ;
12081
12082   arg1 = (Dali::Matrix3 *)jarg1;
12083   arg2 = (Dali::Matrix3 *)jarg2;
12084   if (!arg2) {
12085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12086     return 0;
12087   }
12088   {
12089     try {
12090       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
12091     } catch (std::out_of_range& e) {
12092       {
12093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12094       };
12095     } catch (std::exception& e) {
12096       {
12097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12098       };
12099     } catch (...) {
12100       {
12101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12102       };
12103     }
12104   }
12105   jresult = (void *)result;
12106   return jresult;
12107 }
12108
12109
12110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
12111   void * jresult ;
12112   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12113   Dali::Matrix *arg2 = 0 ;
12114   Dali::Matrix3 *result = 0 ;
12115
12116   arg1 = (Dali::Matrix3 *)jarg1;
12117   arg2 = (Dali::Matrix *)jarg2;
12118   if (!arg2) {
12119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12120     return 0;
12121   }
12122   {
12123     try {
12124       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12125     } catch (std::out_of_range& e) {
12126       {
12127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12128       };
12129     } catch (std::exception& e) {
12130       {
12131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12132       };
12133     } catch (...) {
12134       {
12135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12136       };
12137     }
12138   }
12139   jresult = (void *)result;
12140   return jresult;
12141 }
12142
12143
12144 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
12145   unsigned int jresult ;
12146   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12147   Dali::Matrix3 *arg2 = 0 ;
12148   bool result;
12149
12150   arg1 = (Dali::Matrix3 *)jarg1;
12151   arg2 = (Dali::Matrix3 *)jarg2;
12152   if (!arg2) {
12153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12154     return 0;
12155   }
12156   {
12157     try {
12158       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
12159     } catch (std::out_of_range& e) {
12160       {
12161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12162       };
12163     } catch (std::exception& e) {
12164       {
12165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12166       };
12167     } catch (...) {
12168       {
12169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12170       };
12171     }
12172   }
12173   jresult = result;
12174   return jresult;
12175 }
12176
12177
12178 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
12179   unsigned int jresult ;
12180   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12181   Dali::Matrix3 *arg2 = 0 ;
12182   bool result;
12183
12184   arg1 = (Dali::Matrix3 *)jarg1;
12185   arg2 = (Dali::Matrix3 *)jarg2;
12186   if (!arg2) {
12187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12188     return 0;
12189   }
12190   {
12191     try {
12192       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
12193     } catch (std::out_of_range& e) {
12194       {
12195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12196       };
12197     } catch (std::exception& e) {
12198       {
12199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12200       };
12201     } catch (...) {
12202       {
12203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12204       };
12205     }
12206   }
12207   jresult = result;
12208   return jresult;
12209 }
12210
12211
12212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
12213   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12214
12215   arg1 = (Dali::Matrix3 *)jarg1;
12216   {
12217     try {
12218       delete arg1;
12219     } catch (std::out_of_range& e) {
12220       {
12221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12222       };
12223     } catch (std::exception& e) {
12224       {
12225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12226       };
12227     } catch (...) {
12228       {
12229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12230       };
12231     }
12232   }
12233 }
12234
12235
12236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
12237   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12238
12239   arg1 = (Dali::Matrix3 *)jarg1;
12240   {
12241     try {
12242       (arg1)->SetIdentity();
12243     } catch (std::out_of_range& e) {
12244       {
12245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12246       };
12247     } catch (std::exception& e) {
12248       {
12249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12250       };
12251     } catch (...) {
12252       {
12253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12254       };
12255     }
12256   }
12257 }
12258
12259
12260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
12261   void * jresult ;
12262   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12263   float *result = 0 ;
12264
12265   arg1 = (Dali::Matrix3 *)jarg1;
12266   {
12267     try {
12268       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
12269     } catch (std::out_of_range& e) {
12270       {
12271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12272       };
12273     } catch (std::exception& e) {
12274       {
12275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12276       };
12277     } catch (...) {
12278       {
12279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12280       };
12281     }
12282   }
12283   jresult = (void *)result;
12284   return jresult;
12285 }
12286
12287
12288 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
12289   unsigned int jresult ;
12290   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12291   bool result;
12292
12293   arg1 = (Dali::Matrix3 *)jarg1;
12294   {
12295     try {
12296       result = (bool)(arg1)->Invert();
12297     } catch (std::out_of_range& e) {
12298       {
12299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12300       };
12301     } catch (std::exception& e) {
12302       {
12303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12304       };
12305     } catch (...) {
12306       {
12307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12308       };
12309     }
12310   }
12311   jresult = result;
12312   return jresult;
12313 }
12314
12315
12316 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
12317   unsigned int jresult ;
12318   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12319   bool result;
12320
12321   arg1 = (Dali::Matrix3 *)jarg1;
12322   {
12323     try {
12324       result = (bool)(arg1)->Transpose();
12325     } catch (std::out_of_range& e) {
12326       {
12327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12328       };
12329     } catch (std::exception& e) {
12330       {
12331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12332       };
12333     } catch (...) {
12334       {
12335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12336       };
12337     }
12338   }
12339   jresult = result;
12340   return jresult;
12341 }
12342
12343
12344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
12345   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12346   float arg2 ;
12347
12348   arg1 = (Dali::Matrix3 *)jarg1;
12349   arg2 = (float)jarg2;
12350   {
12351     try {
12352       (arg1)->Scale(arg2);
12353     } catch (std::out_of_range& e) {
12354       {
12355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12356       };
12357     } catch (std::exception& e) {
12358       {
12359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12360       };
12361     } catch (...) {
12362       {
12363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12364       };
12365     }
12366   }
12367 }
12368
12369
12370 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
12371   float jresult ;
12372   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12373   float result;
12374
12375   arg1 = (Dali::Matrix3 *)jarg1;
12376   {
12377     try {
12378       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
12379     } catch (std::out_of_range& e) {
12380       {
12381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12382       };
12383     } catch (std::exception& e) {
12384       {
12385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12386       };
12387     } catch (...) {
12388       {
12389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12390       };
12391     }
12392   }
12393   jresult = result;
12394   return jresult;
12395 }
12396
12397
12398 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
12399   unsigned int jresult ;
12400   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12401   bool result;
12402
12403   arg1 = (Dali::Matrix3 *)jarg1;
12404   {
12405     try {
12406       result = (bool)(arg1)->ScaledInverseTranspose();
12407     } catch (std::out_of_range& e) {
12408       {
12409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12410       };
12411     } catch (std::exception& e) {
12412       {
12413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12414       };
12415     } catch (...) {
12416       {
12417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12418       };
12419     }
12420   }
12421   jresult = result;
12422   return jresult;
12423 }
12424
12425
12426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
12427   Dali::Matrix3 *arg1 = 0 ;
12428   Dali::Matrix3 *arg2 = 0 ;
12429   Dali::Matrix3 *arg3 = 0 ;
12430
12431   arg1 = (Dali::Matrix3 *)jarg1;
12432   if (!arg1) {
12433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
12434     return ;
12435   }
12436   arg2 = (Dali::Matrix3 *)jarg2;
12437   if (!arg2) {
12438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12439     return ;
12440   }
12441   arg3 = (Dali::Matrix3 *)jarg3;
12442   if (!arg3) {
12443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12444     return ;
12445   }
12446   {
12447     try {
12448       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
12449     } catch (std::out_of_range& e) {
12450       {
12451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12452       };
12453     } catch (std::exception& e) {
12454       {
12455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12456       };
12457     } catch (...) {
12458       {
12459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12460       };
12461     }
12462   }
12463 }
12464
12465
12466 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
12467   float jresult ;
12468   float arg1 ;
12469   float arg2 ;
12470   float result;
12471
12472   arg1 = (float)jarg1;
12473   arg2 = (float)jarg2;
12474   {
12475     try {
12476       result = (float)Dali::Random::Range(arg1,arg2);
12477     } catch (std::out_of_range& e) {
12478       {
12479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12480       };
12481     } catch (std::exception& e) {
12482       {
12483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12484       };
12485     } catch (...) {
12486       {
12487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12488       };
12489     }
12490   }
12491   jresult = result;
12492   return jresult;
12493 }
12494
12495
12496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
12497   void * jresult ;
12498   Dali::Vector4 result;
12499
12500   {
12501     try {
12502       result = Dali::Random::Axis();
12503     } catch (std::out_of_range& e) {
12504       {
12505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12506       };
12507     } catch (std::exception& e) {
12508       {
12509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12510       };
12511     } catch (...) {
12512       {
12513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12514       };
12515     }
12516   }
12517   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
12518   return jresult;
12519 }
12520
12521
12522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
12523   void * jresult ;
12524   Dali::AngleAxis *result = 0 ;
12525
12526   {
12527     try {
12528       result = (Dali::AngleAxis *)new Dali::AngleAxis();
12529     } catch (std::out_of_range& e) {
12530       {
12531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12532       };
12533     } catch (std::exception& e) {
12534       {
12535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12536       };
12537     } catch (...) {
12538       {
12539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12540       };
12541     }
12542   }
12543   jresult = (void *)result;
12544   return jresult;
12545 }
12546
12547
12548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
12549   void * jresult ;
12550   Dali::Radian arg1 ;
12551   Dali::Vector3 *arg2 = 0 ;
12552   Dali::Radian *argp1 ;
12553   Dali::AngleAxis *result = 0 ;
12554
12555   argp1 = (Dali::Radian *)jarg1;
12556   if (!argp1) {
12557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
12558     return 0;
12559   }
12560   arg1 = *argp1;
12561   arg2 = (Dali::Vector3 *)jarg2;
12562   if (!arg2) {
12563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12564     return 0;
12565   }
12566   {
12567     try {
12568       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
12569     } catch (std::out_of_range& e) {
12570       {
12571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12572       };
12573     } catch (std::exception& e) {
12574       {
12575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12576       };
12577     } catch (...) {
12578       {
12579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12580       };
12581     }
12582   }
12583   jresult = (void *)result;
12584   return jresult;
12585 }
12586
12587
12588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
12589   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12590   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
12591
12592   arg1 = (Dali::AngleAxis *)jarg1;
12593   arg2 = (Dali::Radian *)jarg2;
12594   if (arg1) (arg1)->angle = *arg2;
12595 }
12596
12597
12598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
12599   void * jresult ;
12600   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12601   Dali::Radian *result = 0 ;
12602
12603   arg1 = (Dali::AngleAxis *)jarg1;
12604   result = (Dali::Radian *)& ((arg1)->angle);
12605   jresult = (void *)result;
12606   return jresult;
12607 }
12608
12609
12610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
12611   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12612   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
12613
12614   arg1 = (Dali::AngleAxis *)jarg1;
12615   arg2 = (Dali::Vector3 *)jarg2;
12616   if (arg1) (arg1)->axis = *arg2;
12617 }
12618
12619
12620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
12621   void * jresult ;
12622   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12623   Dali::Vector3 *result = 0 ;
12624
12625   arg1 = (Dali::AngleAxis *)jarg1;
12626   result = (Dali::Vector3 *)& ((arg1)->axis);
12627   jresult = (void *)result;
12628   return jresult;
12629 }
12630
12631
12632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
12633   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12634
12635   arg1 = (Dali::AngleAxis *)jarg1;
12636   {
12637     try {
12638       delete arg1;
12639     } catch (std::out_of_range& e) {
12640       {
12641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12642       };
12643     } catch (std::exception& e) {
12644       {
12645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12646       };
12647     } catch (...) {
12648       {
12649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12650       };
12651     }
12652   }
12653 }
12654
12655
12656 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
12657   unsigned int jresult ;
12658   Dali::AngleAxis *arg1 = 0 ;
12659   Dali::AngleAxis *arg2 = 0 ;
12660   bool result;
12661
12662   arg1 = (Dali::AngleAxis *)jarg1;
12663   if (!arg1) {
12664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12665     return 0;
12666   }
12667   arg2 = (Dali::AngleAxis *)jarg2;
12668   if (!arg2) {
12669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12670     return 0;
12671   }
12672   {
12673     try {
12674       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
12675     } catch (std::out_of_range& e) {
12676       {
12677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12678       };
12679     } catch (std::exception& e) {
12680       {
12681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12682       };
12683     } catch (...) {
12684       {
12685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12686       };
12687     }
12688   }
12689   jresult = result;
12690   return jresult;
12691 }
12692
12693
12694 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
12695   unsigned int jresult ;
12696   unsigned int arg1 ;
12697   unsigned int result;
12698
12699   arg1 = (unsigned int)jarg1;
12700   {
12701     try {
12702       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
12703     } catch (std::out_of_range& e) {
12704       {
12705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12706       };
12707     } catch (std::exception& e) {
12708       {
12709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12710       };
12711     } catch (...) {
12712       {
12713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12714       };
12715     }
12716   }
12717   jresult = result;
12718   return jresult;
12719 }
12720
12721
12722 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
12723   unsigned int jresult ;
12724   unsigned int arg1 ;
12725   bool result;
12726
12727   arg1 = (unsigned int)jarg1;
12728   {
12729     try {
12730       result = (bool)Dali::IsPowerOfTwo(arg1);
12731     } catch (std::out_of_range& e) {
12732       {
12733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12734       };
12735     } catch (std::exception& e) {
12736       {
12737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12738       };
12739     } catch (...) {
12740       {
12741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12742       };
12743     }
12744   }
12745   jresult = result;
12746   return jresult;
12747 }
12748
12749
12750 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
12751   float jresult ;
12752   float arg1 ;
12753   float arg2 ;
12754   float result;
12755
12756   arg1 = (float)jarg1;
12757   arg2 = (float)jarg2;
12758   {
12759     try {
12760       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
12761     } catch (std::out_of_range& e) {
12762       {
12763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12764       };
12765     } catch (std::exception& e) {
12766       {
12767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12768       };
12769     } catch (...) {
12770       {
12771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12772       };
12773     }
12774   }
12775   jresult = result;
12776   return jresult;
12777 }
12778
12779
12780 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
12781   unsigned int jresult ;
12782   float arg1 ;
12783   bool result;
12784
12785   arg1 = (float)jarg1;
12786   {
12787     try {
12788       result = (bool)Dali::EqualsZero(arg1);
12789     } catch (std::out_of_range& e) {
12790       {
12791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12792       };
12793     } catch (std::exception& e) {
12794       {
12795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12796       };
12797     } catch (...) {
12798       {
12799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12800       };
12801     }
12802   }
12803   jresult = result;
12804   return jresult;
12805 }
12806
12807
12808 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
12809   unsigned int jresult ;
12810   float arg1 ;
12811   float arg2 ;
12812   bool result;
12813
12814   arg1 = (float)jarg1;
12815   arg2 = (float)jarg2;
12816   {
12817     try {
12818       result = (bool)Dali::Equals(arg1,arg2);
12819     } catch (std::out_of_range& e) {
12820       {
12821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12822       };
12823     } catch (std::exception& e) {
12824       {
12825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12826       };
12827     } catch (...) {
12828       {
12829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12830       };
12831     }
12832   }
12833   jresult = result;
12834   return jresult;
12835 }
12836
12837
12838 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
12839   unsigned int jresult ;
12840   float arg1 ;
12841   float arg2 ;
12842   float arg3 ;
12843   bool result;
12844
12845   arg1 = (float)jarg1;
12846   arg2 = (float)jarg2;
12847   arg3 = (float)jarg3;
12848   {
12849     try {
12850       result = (bool)Dali::Equals(arg1,arg2,arg3);
12851     } catch (std::out_of_range& e) {
12852       {
12853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12854       };
12855     } catch (std::exception& e) {
12856       {
12857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12858       };
12859     } catch (...) {
12860       {
12861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12862       };
12863     }
12864   }
12865   jresult = result;
12866   return jresult;
12867 }
12868
12869
12870 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
12871   float jresult ;
12872   float arg1 ;
12873   int arg2 ;
12874   float result;
12875
12876   arg1 = (float)jarg1;
12877   arg2 = (int)jarg2;
12878   {
12879     try {
12880       result = (float)Dali::Round(arg1,arg2);
12881     } catch (std::out_of_range& e) {
12882       {
12883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12884       };
12885     } catch (std::exception& e) {
12886       {
12887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12888       };
12889     } catch (...) {
12890       {
12891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12892       };
12893     }
12894   }
12895   jresult = result;
12896   return jresult;
12897 }
12898
12899
12900 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
12901   float jresult ;
12902   float arg1 ;
12903   float arg2 ;
12904   float arg3 ;
12905   float result;
12906
12907   arg1 = (float)jarg1;
12908   arg2 = (float)jarg2;
12909   arg3 = (float)jarg3;
12910   {
12911     try {
12912       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
12913     } catch (std::out_of_range& e) {
12914       {
12915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12916       };
12917     } catch (std::exception& e) {
12918       {
12919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12920       };
12921     } catch (...) {
12922       {
12923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12924       };
12925     }
12926   }
12927   jresult = result;
12928   return jresult;
12929 }
12930
12931
12932 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
12933   float jresult ;
12934   float arg1 ;
12935   float arg2 ;
12936   float arg3 ;
12937   float arg4 ;
12938   float result;
12939
12940   arg1 = (float)jarg1;
12941   arg2 = (float)jarg2;
12942   arg3 = (float)jarg3;
12943   arg4 = (float)jarg4;
12944   {
12945     try {
12946       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
12947     } catch (std::out_of_range& e) {
12948       {
12949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12950       };
12951     } catch (std::exception& e) {
12952       {
12953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12954       };
12955     } catch (...) {
12956       {
12957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12958       };
12959     }
12960   }
12961   jresult = result;
12962   return jresult;
12963 }
12964
12965
12966 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
12967   int jresult ;
12968   int result;
12969
12970   result = (int)(int)Dali::Property::INVALID_INDEX;
12971   jresult = result;
12972   return jresult;
12973 }
12974
12975
12976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
12977   int jresult ;
12978   int result;
12979
12980   result = (int)(int)Dali::Property::INVALID_KEY;
12981   jresult = result;
12982   return jresult;
12983 }
12984
12985
12986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
12987   int jresult ;
12988   int result;
12989
12990   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
12991   jresult = result;
12992   return jresult;
12993 }
12994
12995
12996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
12997   void * jresult ;
12998   Dali::Handle *arg1 = 0 ;
12999   Dali::Property::Index arg2 ;
13000   Dali::Property *result = 0 ;
13001
13002   arg1 = (Dali::Handle *)jarg1;
13003   if (!arg1) {
13004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13005     return 0;
13006   }
13007   arg2 = (Dali::Property::Index)jarg2;
13008   {
13009     try {
13010       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
13011     } catch (std::out_of_range& e) {
13012       {
13013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13014       };
13015     } catch (std::exception& e) {
13016       {
13017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13018       };
13019     } catch (...) {
13020       {
13021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13022       };
13023     }
13024   }
13025   jresult = (void *)result;
13026   return jresult;
13027 }
13028
13029
13030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
13031   void * jresult ;
13032   Dali::Handle *arg1 = 0 ;
13033   Dali::Property::Index arg2 ;
13034   int arg3 ;
13035   Dali::Property *result = 0 ;
13036
13037   arg1 = (Dali::Handle *)jarg1;
13038   if (!arg1) {
13039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13040     return 0;
13041   }
13042   arg2 = (Dali::Property::Index)jarg2;
13043   arg3 = (int)jarg3;
13044   {
13045     try {
13046       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
13047     } catch (std::out_of_range& e) {
13048       {
13049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13050       };
13051     } catch (std::exception& e) {
13052       {
13053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13054       };
13055     } catch (...) {
13056       {
13057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13058       };
13059     }
13060   }
13061   jresult = (void *)result;
13062   return jresult;
13063 }
13064
13065
13066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
13067   void * jresult ;
13068   Dali::Handle *arg1 = 0 ;
13069   std::string *arg2 = 0 ;
13070   Dali::Property *result = 0 ;
13071
13072   arg1 = (Dali::Handle *)jarg1;
13073   if (!arg1) {
13074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13075     return 0;
13076   }
13077   if (!jarg2) {
13078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13079     return 0;
13080   }
13081   std::string arg2_str(jarg2);
13082   arg2 = &arg2_str;
13083   {
13084     try {
13085       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
13086     } catch (std::out_of_range& e) {
13087       {
13088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13089       };
13090     } catch (std::exception& e) {
13091       {
13092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13093       };
13094     } catch (...) {
13095       {
13096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13097       };
13098     }
13099   }
13100   jresult = (void *)result;
13101
13102   //argout typemap for const std::string&
13103
13104   return jresult;
13105 }
13106
13107
13108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
13109   void * jresult ;
13110   Dali::Handle *arg1 = 0 ;
13111   std::string *arg2 = 0 ;
13112   int arg3 ;
13113   Dali::Property *result = 0 ;
13114
13115   arg1 = (Dali::Handle *)jarg1;
13116   if (!arg1) {
13117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13118     return 0;
13119   }
13120   if (!jarg2) {
13121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13122     return 0;
13123   }
13124   std::string arg2_str(jarg2);
13125   arg2 = &arg2_str;
13126   arg3 = (int)jarg3;
13127   {
13128     try {
13129       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
13130     } catch (std::out_of_range& e) {
13131       {
13132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13133       };
13134     } catch (std::exception& e) {
13135       {
13136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13137       };
13138     } catch (...) {
13139       {
13140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13141       };
13142     }
13143   }
13144   jresult = (void *)result;
13145
13146   //argout typemap for const std::string&
13147
13148   return jresult;
13149 }
13150
13151
13152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
13153   Dali::Property *arg1 = (Dali::Property *) 0 ;
13154
13155   arg1 = (Dali::Property *)jarg1;
13156   {
13157     try {
13158       delete arg1;
13159     } catch (std::out_of_range& e) {
13160       {
13161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13162       };
13163     } catch (std::exception& e) {
13164       {
13165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13166       };
13167     } catch (...) {
13168       {
13169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13170       };
13171     }
13172   }
13173 }
13174
13175
13176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
13177   Dali::Property *arg1 = (Dali::Property *) 0 ;
13178   Dali::Handle *arg2 = 0 ;
13179
13180   arg1 = (Dali::Property *)jarg1;
13181   arg2 = (Dali::Handle *)jarg2;
13182   if (!arg2) {
13183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13184     return ;
13185   }
13186   if (arg1) (arg1)->object = *arg2;
13187 }
13188
13189
13190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
13191   void * jresult ;
13192   Dali::Property *arg1 = (Dali::Property *) 0 ;
13193   Dali::Handle *result = 0 ;
13194
13195   arg1 = (Dali::Property *)jarg1;
13196   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
13197   jresult = (void *)result;
13198   return jresult;
13199 }
13200
13201
13202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
13203   Dali::Property *arg1 = (Dali::Property *) 0 ;
13204   Dali::Property::Index arg2 ;
13205
13206   arg1 = (Dali::Property *)jarg1;
13207   arg2 = (Dali::Property::Index)jarg2;
13208   if (arg1) (arg1)->propertyIndex = arg2;
13209 }
13210
13211
13212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
13213   int jresult ;
13214   Dali::Property *arg1 = (Dali::Property *) 0 ;
13215   Dali::Property::Index result;
13216
13217   arg1 = (Dali::Property *)jarg1;
13218   result = (Dali::Property::Index) ((arg1)->propertyIndex);
13219   jresult = result;
13220   return jresult;
13221 }
13222
13223
13224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
13225   Dali::Property *arg1 = (Dali::Property *) 0 ;
13226   int arg2 ;
13227
13228   arg1 = (Dali::Property *)jarg1;
13229   arg2 = (int)jarg2;
13230   if (arg1) (arg1)->componentIndex = arg2;
13231 }
13232
13233
13234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
13235   int jresult ;
13236   Dali::Property *arg1 = (Dali::Property *) 0 ;
13237   int result;
13238
13239   arg1 = (Dali::Property *)jarg1;
13240   result = (int) ((arg1)->componentIndex);
13241   jresult = result;
13242   return jresult;
13243 }
13244
13245
13246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
13247   void * jresult ;
13248   Dali::Property::Array *result = 0 ;
13249
13250   {
13251     try {
13252       result = (Dali::Property::Array *)new Dali::Property::Array();
13253     } catch (std::out_of_range& e) {
13254       {
13255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13256       };
13257     } catch (std::exception& e) {
13258       {
13259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13260       };
13261     } catch (...) {
13262       {
13263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13264       };
13265     }
13266   }
13267   jresult = (void *)result;
13268   return jresult;
13269 }
13270
13271
13272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
13273   void * jresult ;
13274   Dali::Property::Array *arg1 = 0 ;
13275   Dali::Property::Array *result = 0 ;
13276
13277   arg1 = (Dali::Property::Array *)jarg1;
13278   if (!arg1) {
13279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13280     return 0;
13281   }
13282   {
13283     try {
13284       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
13285     } catch (std::out_of_range& e) {
13286       {
13287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13288       };
13289     } catch (std::exception& e) {
13290       {
13291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13292       };
13293     } catch (...) {
13294       {
13295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13296       };
13297     }
13298   }
13299   jresult = (void *)result;
13300   return jresult;
13301 }
13302
13303
13304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
13305   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13306
13307   arg1 = (Dali::Property::Array *)jarg1;
13308   {
13309     try {
13310       delete arg1;
13311     } catch (std::out_of_range& e) {
13312       {
13313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13314       };
13315     } catch (std::exception& e) {
13316       {
13317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13318       };
13319     } catch (...) {
13320       {
13321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13322       };
13323     }
13324   }
13325 }
13326
13327
13328 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
13329   unsigned long jresult ;
13330   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13331   Dali::Property::Array::SizeType result;
13332
13333   arg1 = (Dali::Property::Array *)jarg1;
13334   {
13335     try {
13336       result = ((Dali::Property::Array const *)arg1)->Size();
13337     } catch (std::out_of_range& e) {
13338       {
13339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13340       };
13341     } catch (std::exception& e) {
13342       {
13343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13344       };
13345     } catch (...) {
13346       {
13347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13348       };
13349     }
13350   }
13351   jresult = (unsigned long)result;
13352   return jresult;
13353 }
13354
13355
13356 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
13357   unsigned long jresult ;
13358   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13359   Dali::Property::Array::SizeType result;
13360
13361   arg1 = (Dali::Property::Array *)jarg1;
13362   {
13363     try {
13364       result = ((Dali::Property::Array const *)arg1)->Count();
13365     } catch (std::out_of_range& e) {
13366       {
13367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13368       };
13369     } catch (std::exception& e) {
13370       {
13371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13372       };
13373     } catch (...) {
13374       {
13375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13376       };
13377     }
13378   }
13379   jresult = (unsigned long)result;
13380   return jresult;
13381 }
13382
13383
13384 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
13385   unsigned int jresult ;
13386   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13387   bool result;
13388
13389   arg1 = (Dali::Property::Array *)jarg1;
13390   {
13391     try {
13392       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
13393     } catch (std::out_of_range& e) {
13394       {
13395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13396       };
13397     } catch (std::exception& e) {
13398       {
13399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13400       };
13401     } catch (...) {
13402       {
13403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13404       };
13405     }
13406   }
13407   jresult = result;
13408   return jresult;
13409 }
13410
13411
13412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
13413   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13414
13415   arg1 = (Dali::Property::Array *)jarg1;
13416   {
13417     try {
13418       (arg1)->Clear();
13419     } catch (std::out_of_range& e) {
13420       {
13421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13422       };
13423     } catch (std::exception& e) {
13424       {
13425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13426       };
13427     } catch (...) {
13428       {
13429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13430       };
13431     }
13432   }
13433 }
13434
13435
13436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
13437   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13438   Dali::Property::Array::SizeType arg2 ;
13439
13440   arg1 = (Dali::Property::Array *)jarg1;
13441   arg2 = (Dali::Property::Array::SizeType)jarg2;
13442   {
13443     try {
13444       (arg1)->Reserve(arg2);
13445     } catch (std::out_of_range& e) {
13446       {
13447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13448       };
13449     } catch (std::exception& e) {
13450       {
13451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13452       };
13453     } catch (...) {
13454       {
13455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13456       };
13457     }
13458   }
13459 }
13460
13461
13462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
13463   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13464   Dali::Property::Array::SizeType arg2 ;
13465
13466   arg1 = (Dali::Property::Array *)jarg1;
13467   arg2 = (Dali::Property::Array::SizeType)jarg2;
13468   {
13469     try {
13470       (arg1)->Resize(arg2);
13471     } catch (std::out_of_range& e) {
13472       {
13473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13474       };
13475     } catch (std::exception& e) {
13476       {
13477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13478       };
13479     } catch (...) {
13480       {
13481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13482       };
13483     }
13484   }
13485 }
13486
13487
13488 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
13489   unsigned long jresult ;
13490   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13491   Dali::Property::Array::SizeType result;
13492
13493   arg1 = (Dali::Property::Array *)jarg1;
13494   {
13495     try {
13496       result = (arg1)->Capacity();
13497     } catch (std::out_of_range& e) {
13498       {
13499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13500       };
13501     } catch (std::exception& e) {
13502       {
13503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13504       };
13505     } catch (...) {
13506       {
13507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13508       };
13509     }
13510   }
13511   jresult = (unsigned long)result;
13512   return jresult;
13513 }
13514
13515
13516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
13517   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13518   Dali::Property::Value *arg2 = 0 ;
13519
13520   arg1 = (Dali::Property::Array *)jarg1;
13521   arg2 = (Dali::Property::Value *)jarg2;
13522   if (!arg2) {
13523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13524     return ;
13525   }
13526   {
13527     try {
13528       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
13529     } catch (std::out_of_range& e) {
13530       {
13531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13532       };
13533     } catch (std::exception& e) {
13534       {
13535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13536       };
13537     } catch (...) {
13538       {
13539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13540       };
13541     }
13542   }
13543 }
13544
13545
13546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
13547   void * jresult ;
13548   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13549   Dali::Property::Value *arg2 = 0 ;
13550   Dali::Property::Array *result = 0 ;
13551
13552   arg1 = (Dali::Property::Array *)jarg1;
13553   arg2 = (Dali::Property::Value *)jarg2;
13554   if (!arg2) {
13555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13556     return 0;
13557   }
13558   {
13559     try {
13560       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
13561     } catch (std::out_of_range& e) {
13562       {
13563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13564       };
13565     } catch (std::exception& e) {
13566       {
13567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13568       };
13569     } catch (...) {
13570       {
13571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13572       };
13573     }
13574   }
13575   jresult = (void *)result;
13576   return jresult;
13577 }
13578
13579
13580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
13581   void * jresult ;
13582   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13583   Dali::Property::Array::SizeType arg2 ;
13584   Dali::Property::Value *result = 0 ;
13585
13586   arg1 = (Dali::Property::Array *)jarg1;
13587   arg2 = (Dali::Property::Array::SizeType)jarg2;
13588   {
13589     try {
13590       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
13591     } catch (std::out_of_range& e) {
13592       {
13593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13594       };
13595     } catch (std::exception& e) {
13596       {
13597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13598       };
13599     } catch (...) {
13600       {
13601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13602       };
13603     }
13604   }
13605   jresult = (void *)result;
13606   return jresult;
13607 }
13608
13609
13610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
13611   void * jresult ;
13612   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13613   Dali::Property::Array::SizeType arg2 ;
13614   Dali::Property::Value *result = 0 ;
13615
13616   arg1 = (Dali::Property::Array *)jarg1;
13617   arg2 = (Dali::Property::Array::SizeType)jarg2;
13618   {
13619     try {
13620       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
13621     } catch (std::out_of_range& e) {
13622       {
13623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13624       };
13625     } catch (std::exception& e) {
13626       {
13627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13628       };
13629     } catch (...) {
13630       {
13631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13632       };
13633     }
13634   }
13635   jresult = (void *)result;
13636   return jresult;
13637 }
13638
13639
13640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
13641   void * jresult ;
13642   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13643   Dali::Property::Array *arg2 = 0 ;
13644   Dali::Property::Array *result = 0 ;
13645
13646   arg1 = (Dali::Property::Array *)jarg1;
13647   arg2 = (Dali::Property::Array *)jarg2;
13648   if (!arg2) {
13649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13650     return 0;
13651   }
13652   {
13653     try {
13654       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
13655     } catch (std::out_of_range& e) {
13656       {
13657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13658       };
13659     } catch (std::exception& e) {
13660       {
13661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13662       };
13663     } catch (...) {
13664       {
13665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13666       };
13667     }
13668   }
13669   jresult = (void *)result;
13670   return jresult;
13671 }
13672
13673
13674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
13675   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13676   enum Dali::Property::Key::Type arg2 ;
13677
13678   arg1 = (Dali::Property::Key *)jarg1;
13679   arg2 = (enum Dali::Property::Key::Type)jarg2;
13680   if (arg1) (arg1)->type = arg2;
13681 }
13682
13683
13684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
13685   int jresult ;
13686   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13687   enum Dali::Property::Key::Type result;
13688
13689   arg1 = (Dali::Property::Key *)jarg1;
13690   result = (enum Dali::Property::Key::Type) ((arg1)->type);
13691   jresult = (int)result;
13692   return jresult;
13693 }
13694
13695
13696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
13697   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13698   Dali::Property::Index arg2 ;
13699
13700   arg1 = (Dali::Property::Key *)jarg1;
13701   arg2 = (Dali::Property::Index)jarg2;
13702   if (arg1) (arg1)->indexKey = arg2;
13703 }
13704
13705
13706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
13707   int jresult ;
13708   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13709   Dali::Property::Index result;
13710
13711   arg1 = (Dali::Property::Key *)jarg1;
13712   result = (Dali::Property::Index) ((arg1)->indexKey);
13713   jresult = result;
13714   return jresult;
13715 }
13716
13717
13718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
13719   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13720   std::string *arg2 = 0 ;
13721
13722   arg1 = (Dali::Property::Key *)jarg1;
13723   if (!jarg2) {
13724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13725     return ;
13726   }
13727   std::string arg2_str(jarg2);
13728   arg2 = &arg2_str;
13729   if (arg1) (arg1)->stringKey = *arg2;
13730
13731   //argout typemap for const std::string&
13732
13733 }
13734
13735
13736 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
13737   char * jresult ;
13738   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13739   std::string *result = 0 ;
13740
13741   arg1 = (Dali::Property::Key *)jarg1;
13742   result = (std::string *) & ((arg1)->stringKey);
13743   jresult = SWIG_csharp_string_callback(result->c_str());
13744   return jresult;
13745 }
13746
13747
13748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
13749   void * jresult ;
13750   std::string *arg1 = 0 ;
13751   Dali::Property::Key *result = 0 ;
13752
13753   if (!jarg1) {
13754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13755     return 0;
13756   }
13757   std::string arg1_str(jarg1);
13758   arg1 = &arg1_str;
13759   {
13760     try {
13761       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
13762     } catch (std::out_of_range& e) {
13763       {
13764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13765       };
13766     } catch (std::exception& e) {
13767       {
13768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13769       };
13770     } catch (...) {
13771       {
13772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13773       };
13774     }
13775   }
13776   jresult = (void *)result;
13777
13778   //argout typemap for const std::string&
13779
13780   return jresult;
13781 }
13782
13783
13784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
13785   void * jresult ;
13786   Dali::Property::Index arg1 ;
13787   Dali::Property::Key *result = 0 ;
13788
13789   arg1 = (Dali::Property::Index)jarg1;
13790   {
13791     try {
13792       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
13793     } catch (std::out_of_range& e) {
13794       {
13795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13796       };
13797     } catch (std::exception& e) {
13798       {
13799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13800       };
13801     } catch (...) {
13802       {
13803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13804       };
13805     }
13806   }
13807   jresult = (void *)result;
13808   return jresult;
13809 }
13810
13811
13812 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
13813   unsigned int jresult ;
13814   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13815   std::string *arg2 = 0 ;
13816   bool result;
13817
13818   arg1 = (Dali::Property::Key *)jarg1;
13819   if (!jarg2) {
13820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13821     return 0;
13822   }
13823   std::string arg2_str(jarg2);
13824   arg2 = &arg2_str;
13825   {
13826     try {
13827       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
13828     } catch (std::out_of_range& e) {
13829       {
13830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13831       };
13832     } catch (std::exception& e) {
13833       {
13834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13835       };
13836     } catch (...) {
13837       {
13838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13839       };
13840     }
13841   }
13842   jresult = result;
13843
13844   //argout typemap for const std::string&
13845
13846   return jresult;
13847 }
13848
13849
13850 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
13851   unsigned int jresult ;
13852   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13853   Dali::Property::Index arg2 ;
13854   bool result;
13855
13856   arg1 = (Dali::Property::Key *)jarg1;
13857   arg2 = (Dali::Property::Index)jarg2;
13858   {
13859     try {
13860       result = (bool)(arg1)->operator ==(arg2);
13861     } catch (std::out_of_range& e) {
13862       {
13863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13864       };
13865     } catch (std::exception& e) {
13866       {
13867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13868       };
13869     } catch (...) {
13870       {
13871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13872       };
13873     }
13874   }
13875   jresult = result;
13876   return jresult;
13877 }
13878
13879
13880 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
13881   unsigned int jresult ;
13882   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13883   Dali::Property::Key *arg2 = 0 ;
13884   bool result;
13885
13886   arg1 = (Dali::Property::Key *)jarg1;
13887   arg2 = (Dali::Property::Key *)jarg2;
13888   if (!arg2) {
13889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13890     return 0;
13891   }
13892   {
13893     try {
13894       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
13895     } catch (std::out_of_range& e) {
13896       {
13897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13898       };
13899     } catch (std::exception& e) {
13900       {
13901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13902       };
13903     } catch (...) {
13904       {
13905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13906       };
13907     }
13908   }
13909   jresult = result;
13910   return jresult;
13911 }
13912
13913
13914 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
13915   unsigned int jresult ;
13916   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13917   std::string *arg2 = 0 ;
13918   bool result;
13919
13920   arg1 = (Dali::Property::Key *)jarg1;
13921   if (!jarg2) {
13922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13923     return 0;
13924   }
13925   std::string arg2_str(jarg2);
13926   arg2 = &arg2_str;
13927   {
13928     try {
13929       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
13930     } catch (std::out_of_range& e) {
13931       {
13932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13933       };
13934     } catch (std::exception& e) {
13935       {
13936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13937       };
13938     } catch (...) {
13939       {
13940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13941       };
13942     }
13943   }
13944   jresult = result;
13945
13946   //argout typemap for const std::string&
13947
13948   return jresult;
13949 }
13950
13951
13952 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
13953   unsigned int jresult ;
13954   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13955   Dali::Property::Index arg2 ;
13956   bool result;
13957
13958   arg1 = (Dali::Property::Key *)jarg1;
13959   arg2 = (Dali::Property::Index)jarg2;
13960   {
13961     try {
13962       result = (bool)(arg1)->operator !=(arg2);
13963     } catch (std::out_of_range& e) {
13964       {
13965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13966       };
13967     } catch (std::exception& e) {
13968       {
13969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13970       };
13971     } catch (...) {
13972       {
13973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13974       };
13975     }
13976   }
13977   jresult = result;
13978   return jresult;
13979 }
13980
13981
13982 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
13983   unsigned int jresult ;
13984   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13985   Dali::Property::Key *arg2 = 0 ;
13986   bool result;
13987
13988   arg1 = (Dali::Property::Key *)jarg1;
13989   arg2 = (Dali::Property::Key *)jarg2;
13990   if (!arg2) {
13991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13992     return 0;
13993   }
13994   {
13995     try {
13996       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
13997     } catch (std::out_of_range& e) {
13998       {
13999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14000       };
14001     } catch (std::exception& e) {
14002       {
14003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14004       };
14005     } catch (...) {
14006       {
14007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14008       };
14009     }
14010   }
14011   jresult = result;
14012   return jresult;
14013 }
14014
14015
14016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
14017   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
14018
14019   arg1 = (Dali::Property::Key *)jarg1;
14020   {
14021     try {
14022       delete arg1;
14023     } catch (std::out_of_range& e) {
14024       {
14025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14026       };
14027     } catch (std::exception& e) {
14028       {
14029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14030       };
14031     } catch (...) {
14032       {
14033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14034       };
14035     }
14036   }
14037 }
14038
14039
14040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
14041   void * jresult ;
14042   Dali::Property::Map *result = 0 ;
14043
14044   {
14045     try {
14046       result = (Dali::Property::Map *)new Dali::Property::Map();
14047     } catch (std::out_of_range& e) {
14048       {
14049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14050       };
14051     } catch (std::exception& e) {
14052       {
14053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14054       };
14055     } catch (...) {
14056       {
14057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14058       };
14059     }
14060   }
14061   jresult = (void *)result;
14062   return jresult;
14063 }
14064
14065
14066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
14067   void * jresult ;
14068   Dali::Property::Map *arg1 = 0 ;
14069   Dali::Property::Map *result = 0 ;
14070
14071   arg1 = (Dali::Property::Map *)jarg1;
14072   if (!arg1) {
14073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14074     return 0;
14075   }
14076   {
14077     try {
14078       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
14079     } catch (std::out_of_range& e) {
14080       {
14081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14082       };
14083     } catch (std::exception& e) {
14084       {
14085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14086       };
14087     } catch (...) {
14088       {
14089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14090       };
14091     }
14092   }
14093   jresult = (void *)result;
14094   return jresult;
14095 }
14096
14097
14098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
14099   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14100
14101   arg1 = (Dali::Property::Map *)jarg1;
14102   {
14103     try {
14104       delete arg1;
14105     } catch (std::out_of_range& e) {
14106       {
14107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14108       };
14109     } catch (std::exception& e) {
14110       {
14111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14112       };
14113     } catch (...) {
14114       {
14115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14116       };
14117     }
14118   }
14119 }
14120
14121
14122 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
14123   unsigned long jresult ;
14124   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14125   Dali::Property::Map::SizeType result;
14126
14127   arg1 = (Dali::Property::Map *)jarg1;
14128   {
14129     try {
14130       result = ((Dali::Property::Map const *)arg1)->Count();
14131     } catch (std::out_of_range& e) {
14132       {
14133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14134       };
14135     } catch (std::exception& e) {
14136       {
14137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14138       };
14139     } catch (...) {
14140       {
14141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14142       };
14143     }
14144   }
14145   jresult = (unsigned long)result;
14146   return jresult;
14147 }
14148
14149
14150 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
14151   unsigned int jresult ;
14152   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14153   bool result;
14154
14155   arg1 = (Dali::Property::Map *)jarg1;
14156   {
14157     try {
14158       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
14159     } catch (std::out_of_range& e) {
14160       {
14161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14162       };
14163     } catch (std::exception& e) {
14164       {
14165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14166       };
14167     } catch (...) {
14168       {
14169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14170       };
14171     }
14172   }
14173   jresult = result;
14174   return jresult;
14175 }
14176
14177
14178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14179   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14180   char *arg2 = (char *) 0 ;
14181   Dali::Property::Value *arg3 = 0 ;
14182
14183   arg1 = (Dali::Property::Map *)jarg1;
14184   arg2 = (char *)jarg2;
14185   arg3 = (Dali::Property::Value *)jarg3;
14186   if (!arg3) {
14187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14188     return ;
14189   }
14190   {
14191     try {
14192       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
14193     } catch (std::out_of_range& e) {
14194       {
14195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14196       };
14197     } catch (std::exception& e) {
14198       {
14199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14200       };
14201     } catch (...) {
14202       {
14203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14204       };
14205     }
14206   }
14207 }
14208
14209
14210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14211   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14212   Dali::Property::Index arg2 ;
14213   Dali::Property::Value *arg3 = 0 ;
14214
14215   arg1 = (Dali::Property::Map *)jarg1;
14216   arg2 = (Dali::Property::Index)jarg2;
14217   arg3 = (Dali::Property::Value *)jarg3;
14218   if (!arg3) {
14219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14220     return ;
14221   }
14222   {
14223     try {
14224       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
14225     } catch (std::out_of_range& e) {
14226       {
14227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14228       };
14229     } catch (std::exception& e) {
14230       {
14231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14232       };
14233     } catch (...) {
14234       {
14235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14236       };
14237     }
14238   }
14239 }
14240
14241
14242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14243   void * jresult ;
14244   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14245   char *arg2 = (char *) 0 ;
14246   Dali::Property::Value *arg3 = 0 ;
14247   Dali::Property::Map *result = 0 ;
14248
14249   arg1 = (Dali::Property::Map *)jarg1;
14250   arg2 = (char *)jarg2;
14251   arg3 = (Dali::Property::Value *)jarg3;
14252   if (!arg3) {
14253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14254     return 0;
14255   }
14256   {
14257     try {
14258       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
14259     } catch (std::out_of_range& e) {
14260       {
14261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14262       };
14263     } catch (std::exception& e) {
14264       {
14265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14266       };
14267     } catch (...) {
14268       {
14269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14270       };
14271     }
14272   }
14273   jresult = (void *)result;
14274   return jresult;
14275 }
14276
14277
14278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14279   void * jresult ;
14280   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14281   Dali::Property::Index arg2 ;
14282   Dali::Property::Value *arg3 = 0 ;
14283   Dali::Property::Map *result = 0 ;
14284
14285   arg1 = (Dali::Property::Map *)jarg1;
14286   arg2 = (Dali::Property::Index)jarg2;
14287   arg3 = (Dali::Property::Value *)jarg3;
14288   if (!arg3) {
14289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14290     return 0;
14291   }
14292   {
14293     try {
14294       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
14295     } catch (std::out_of_range& e) {
14296       {
14297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14298       };
14299     } catch (std::exception& e) {
14300       {
14301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14302       };
14303     } catch (...) {
14304       {
14305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14306       };
14307     }
14308   }
14309   jresult = (void *)result;
14310   return jresult;
14311 }
14312
14313
14314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
14315   void * jresult ;
14316   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14317   Dali::Property::Map::SizeType arg2 ;
14318   Dali::Property::Value *result = 0 ;
14319
14320   arg1 = (Dali::Property::Map *)jarg1;
14321   arg2 = (Dali::Property::Map::SizeType)jarg2;
14322   {
14323     try {
14324       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
14325     } catch (std::out_of_range& e) {
14326       {
14327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14328       };
14329     } catch (std::exception& e) {
14330       {
14331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14332       };
14333     } catch (...) {
14334       {
14335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14336       };
14337     }
14338   }
14339   jresult = (void *)result;
14340   return jresult;
14341 }
14342
14343
14344 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
14345   char * jresult ;
14346   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14347   Dali::Property::Map::SizeType arg2 ;
14348   std::string *result = 0 ;
14349
14350   arg1 = (Dali::Property::Map *)jarg1;
14351   arg2 = (Dali::Property::Map::SizeType)jarg2;
14352   {
14353     try {
14354       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
14355     } catch (std::out_of_range& e) {
14356       {
14357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14358       };
14359     } catch (std::exception& e) {
14360       {
14361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14362       };
14363     } catch (...) {
14364       {
14365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14366       };
14367     }
14368   }
14369   jresult = SWIG_csharp_string_callback(result->c_str());
14370   return jresult;
14371 }
14372
14373
14374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
14375   void * jresult ;
14376   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14377   Dali::Property::Map::SizeType arg2 ;
14378   SwigValueWrapper< Dali::Property::Key > result;
14379
14380   arg1 = (Dali::Property::Map *)jarg1;
14381   arg2 = (Dali::Property::Map::SizeType)jarg2;
14382   {
14383     try {
14384       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
14385     } catch (std::out_of_range& e) {
14386       {
14387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14388       };
14389     } catch (std::exception& e) {
14390       {
14391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14392       };
14393     } catch (...) {
14394       {
14395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14396       };
14397     }
14398   }
14399   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
14400   return jresult;
14401 }
14402
14403
14404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
14405   void * jresult ;
14406   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14407   Dali::Property::Map::SizeType arg2 ;
14408   StringValuePair *result = 0 ;
14409
14410   arg1 = (Dali::Property::Map *)jarg1;
14411   arg2 = (Dali::Property::Map::SizeType)jarg2;
14412   {
14413     try {
14414       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
14415     } catch (std::out_of_range& e) {
14416       {
14417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14418       };
14419     } catch (std::exception& e) {
14420       {
14421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14422       };
14423     } catch (...) {
14424       {
14425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14426       };
14427     }
14428   }
14429   jresult = (void *)result;
14430   return jresult;
14431 }
14432
14433
14434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
14435   void * jresult ;
14436   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14437   char *arg2 = (char *) 0 ;
14438   Dali::Property::Value *result = 0 ;
14439
14440   arg1 = (Dali::Property::Map *)jarg1;
14441   arg2 = (char *)jarg2;
14442   {
14443     try {
14444       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
14445     } catch (std::out_of_range& e) {
14446       {
14447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14448       };
14449     } catch (std::exception& e) {
14450       {
14451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14452       };
14453     } catch (...) {
14454       {
14455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14456       };
14457     }
14458   }
14459   jresult = (void *)result;
14460   return jresult;
14461 }
14462
14463
14464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
14465   void * jresult ;
14466   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14467   Dali::Property::Index arg2 ;
14468   Dali::Property::Value *result = 0 ;
14469
14470   arg1 = (Dali::Property::Map *)jarg1;
14471   arg2 = (Dali::Property::Index)jarg2;
14472   {
14473     try {
14474       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
14475     } catch (std::out_of_range& e) {
14476       {
14477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14478       };
14479     } catch (std::exception& e) {
14480       {
14481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14482       };
14483     } catch (...) {
14484       {
14485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14486       };
14487     }
14488   }
14489   jresult = (void *)result;
14490   return jresult;
14491 }
14492
14493
14494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
14495   void * jresult ;
14496   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14497   Dali::Property::Index arg2 ;
14498   std::string *arg3 = 0 ;
14499   Dali::Property::Value *result = 0 ;
14500
14501   arg1 = (Dali::Property::Map *)jarg1;
14502   arg2 = (Dali::Property::Index)jarg2;
14503   if (!jarg3) {
14504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14505     return 0;
14506   }
14507   std::string arg3_str(jarg3);
14508   arg3 = &arg3_str;
14509   {
14510     try {
14511       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
14512     } catch (std::out_of_range& e) {
14513       {
14514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14515       };
14516     } catch (std::exception& e) {
14517       {
14518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14519       };
14520     } catch (...) {
14521       {
14522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14523       };
14524     }
14525   }
14526   jresult = (void *)result;
14527
14528   //argout typemap for const std::string&
14529
14530   return jresult;
14531 }
14532
14533
14534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
14535   void * jresult ;
14536   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14537   std::string *arg2 = 0 ;
14538   Dali::Property::Type arg3 ;
14539   Dali::Property::Value *result = 0 ;
14540
14541   arg1 = (Dali::Property::Map *)jarg1;
14542   if (!jarg2) {
14543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14544     return 0;
14545   }
14546   std::string arg2_str(jarg2);
14547   arg2 = &arg2_str;
14548   arg3 = (Dali::Property::Type)jarg3;
14549   {
14550     try {
14551       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
14552     } catch (std::out_of_range& e) {
14553       {
14554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14555       };
14556     } catch (std::exception& e) {
14557       {
14558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14559       };
14560     } catch (...) {
14561       {
14562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14563       };
14564     }
14565   }
14566   jresult = (void *)result;
14567
14568   //argout typemap for const std::string&
14569
14570   return jresult;
14571 }
14572
14573
14574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
14575   void * jresult ;
14576   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14577   Dali::Property::Index arg2 ;
14578   Dali::Property::Type arg3 ;
14579   Dali::Property::Value *result = 0 ;
14580
14581   arg1 = (Dali::Property::Map *)jarg1;
14582   arg2 = (Dali::Property::Index)jarg2;
14583   arg3 = (Dali::Property::Type)jarg3;
14584   {
14585     try {
14586       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
14587     } catch (std::out_of_range& e) {
14588       {
14589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14590       };
14591     } catch (std::exception& e) {
14592       {
14593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14594       };
14595     } catch (...) {
14596       {
14597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14598       };
14599     }
14600   }
14601   jresult = (void *)result;
14602   return jresult;
14603 }
14604
14605
14606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
14607   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14608
14609   arg1 = (Dali::Property::Map *)jarg1;
14610   {
14611     try {
14612       (arg1)->Clear();
14613     } catch (std::out_of_range& e) {
14614       {
14615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14616       };
14617     } catch (std::exception& e) {
14618       {
14619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14620       };
14621     } catch (...) {
14622       {
14623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14624       };
14625     }
14626   }
14627 }
14628
14629
14630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
14631   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14632   Dali::Property::Map *arg2 = 0 ;
14633
14634   arg1 = (Dali::Property::Map *)jarg1;
14635   arg2 = (Dali::Property::Map *)jarg2;
14636   if (!arg2) {
14637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14638     return ;
14639   }
14640   {
14641     try {
14642       (arg1)->Merge((Dali::Property::Map const &)*arg2);
14643     } catch (std::out_of_range& e) {
14644       {
14645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14646       };
14647     } catch (std::exception& e) {
14648       {
14649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14650       };
14651     } catch (...) {
14652       {
14653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14654       };
14655     }
14656   }
14657 }
14658
14659
14660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
14661   void * jresult ;
14662   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14663   std::string *arg2 = 0 ;
14664   Dali::Property::Value *result = 0 ;
14665
14666   arg1 = (Dali::Property::Map *)jarg1;
14667   if (!jarg2) {
14668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14669     return 0;
14670   }
14671   std::string arg2_str(jarg2);
14672   arg2 = &arg2_str;
14673   {
14674     try {
14675       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
14676     } catch (std::out_of_range& e) {
14677       {
14678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14679       };
14680     } catch (std::exception& e) {
14681       {
14682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14683       };
14684     } catch (...) {
14685       {
14686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14687       };
14688     }
14689   }
14690   jresult = (void *)result;
14691
14692   //argout typemap for const std::string&
14693
14694   return jresult;
14695 }
14696
14697
14698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
14699   void * jresult ;
14700   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14701   Dali::Property::Index arg2 ;
14702   Dali::Property::Value *result = 0 ;
14703
14704   arg1 = (Dali::Property::Map *)jarg1;
14705   arg2 = (Dali::Property::Index)jarg2;
14706   {
14707     try {
14708       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
14709     } catch (std::out_of_range& e) {
14710       {
14711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14712       };
14713     } catch (std::exception& e) {
14714       {
14715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14716       };
14717     } catch (...) {
14718       {
14719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14720       };
14721     }
14722   }
14723   jresult = (void *)result;
14724   return jresult;
14725 }
14726
14727
14728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
14729   void * jresult ;
14730   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14731   Dali::Property::Map *arg2 = 0 ;
14732   Dali::Property::Map *result = 0 ;
14733
14734   arg1 = (Dali::Property::Map *)jarg1;
14735   arg2 = (Dali::Property::Map *)jarg2;
14736   if (!arg2) {
14737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14738     return 0;
14739   }
14740   {
14741     try {
14742       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
14743     } catch (std::out_of_range& e) {
14744       {
14745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14746       };
14747     } catch (std::exception& e) {
14748       {
14749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14750       };
14751     } catch (...) {
14752       {
14753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14754       };
14755     }
14756   }
14757   jresult = (void *)result;
14758   return jresult;
14759 }
14760
14761
14762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
14763   void * jresult ;
14764   Dali::Property::Value *result = 0 ;
14765
14766   {
14767     try {
14768       result = (Dali::Property::Value *)new Dali::Property::Value();
14769     } catch (std::out_of_range& e) {
14770       {
14771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14772       };
14773     } catch (std::exception& e) {
14774       {
14775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14776       };
14777     } catch (...) {
14778       {
14779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14780       };
14781     }
14782   }
14783   jresult = (void *)result;
14784   return jresult;
14785 }
14786
14787
14788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
14789   void * jresult ;
14790   bool arg1 ;
14791   Dali::Property::Value *result = 0 ;
14792
14793   arg1 = jarg1 ? true : false;
14794   {
14795     try {
14796       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14797     } catch (std::out_of_range& e) {
14798       {
14799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14800       };
14801     } catch (std::exception& e) {
14802       {
14803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14804       };
14805     } catch (...) {
14806       {
14807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14808       };
14809     }
14810   }
14811   jresult = (void *)result;
14812   return jresult;
14813 }
14814
14815
14816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
14817   void * jresult ;
14818   int arg1 ;
14819   Dali::Property::Value *result = 0 ;
14820
14821   arg1 = (int)jarg1;
14822   {
14823     try {
14824       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14825     } catch (std::out_of_range& e) {
14826       {
14827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14828       };
14829     } catch (std::exception& e) {
14830       {
14831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14832       };
14833     } catch (...) {
14834       {
14835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14836       };
14837     }
14838   }
14839   jresult = (void *)result;
14840   return jresult;
14841 }
14842
14843
14844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
14845   void * jresult ;
14846   float arg1 ;
14847   Dali::Property::Value *result = 0 ;
14848
14849   arg1 = (float)jarg1;
14850   {
14851     try {
14852       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14853     } catch (std::out_of_range& e) {
14854       {
14855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14856       };
14857     } catch (std::exception& e) {
14858       {
14859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14860       };
14861     } catch (...) {
14862       {
14863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14864       };
14865     }
14866   }
14867   jresult = (void *)result;
14868   return jresult;
14869 }
14870
14871
14872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
14873   void * jresult ;
14874   Dali::Vector2 *arg1 = 0 ;
14875   Dali::Property::Value *result = 0 ;
14876
14877   arg1 = (Dali::Vector2 *)jarg1;
14878   if (!arg1) {
14879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
14880     return 0;
14881   }
14882   {
14883     try {
14884       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
14885     } catch (std::out_of_range& e) {
14886       {
14887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14888       };
14889     } catch (std::exception& e) {
14890       {
14891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14892       };
14893     } catch (...) {
14894       {
14895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14896       };
14897     }
14898   }
14899   jresult = (void *)result;
14900   return jresult;
14901 }
14902
14903
14904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
14905   void * jresult ;
14906   Dali::Vector3 *arg1 = 0 ;
14907   Dali::Property::Value *result = 0 ;
14908
14909   arg1 = (Dali::Vector3 *)jarg1;
14910   if (!arg1) {
14911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14912     return 0;
14913   }
14914   {
14915     try {
14916       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
14917     } catch (std::out_of_range& e) {
14918       {
14919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14920       };
14921     } catch (std::exception& e) {
14922       {
14923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14924       };
14925     } catch (...) {
14926       {
14927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14928       };
14929     }
14930   }
14931   jresult = (void *)result;
14932   return jresult;
14933 }
14934
14935
14936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
14937   void * jresult ;
14938   Dali::Vector4 *arg1 = 0 ;
14939   Dali::Property::Value *result = 0 ;
14940
14941   arg1 = (Dali::Vector4 *)jarg1;
14942   if (!arg1) {
14943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
14944     return 0;
14945   }
14946   {
14947     try {
14948       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
14949     } catch (std::out_of_range& e) {
14950       {
14951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14952       };
14953     } catch (std::exception& e) {
14954       {
14955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14956       };
14957     } catch (...) {
14958       {
14959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14960       };
14961     }
14962   }
14963   jresult = (void *)result;
14964   return jresult;
14965 }
14966
14967
14968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
14969   void * jresult ;
14970   Dali::Matrix3 *arg1 = 0 ;
14971   Dali::Property::Value *result = 0 ;
14972
14973   arg1 = (Dali::Matrix3 *)jarg1;
14974   if (!arg1) {
14975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
14976     return 0;
14977   }
14978   {
14979     try {
14980       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
14981     } catch (std::out_of_range& e) {
14982       {
14983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14984       };
14985     } catch (std::exception& e) {
14986       {
14987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14988       };
14989     } catch (...) {
14990       {
14991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14992       };
14993     }
14994   }
14995   jresult = (void *)result;
14996   return jresult;
14997 }
14998
14999
15000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
15001   void * jresult ;
15002   Dali::Matrix *arg1 = 0 ;
15003   Dali::Property::Value *result = 0 ;
15004
15005   arg1 = (Dali::Matrix *)jarg1;
15006   if (!arg1) {
15007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
15008     return 0;
15009   }
15010   {
15011     try {
15012       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
15013     } catch (std::out_of_range& e) {
15014       {
15015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15016       };
15017     } catch (std::exception& e) {
15018       {
15019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15020       };
15021     } catch (...) {
15022       {
15023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15024       };
15025     }
15026   }
15027   jresult = (void *)result;
15028   return jresult;
15029 }
15030
15031
15032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
15033   void * jresult ;
15034   Dali::Rect< int > *arg1 = 0 ;
15035   Dali::Property::Value *result = 0 ;
15036
15037   arg1 = (Dali::Rect< int > *)jarg1;
15038   if (!arg1) {
15039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
15040     return 0;
15041   }
15042   {
15043     try {
15044       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
15045     } catch (std::out_of_range& e) {
15046       {
15047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15048       };
15049     } catch (std::exception& e) {
15050       {
15051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15052       };
15053     } catch (...) {
15054       {
15055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15056       };
15057     }
15058   }
15059   jresult = (void *)result;
15060   return jresult;
15061 }
15062
15063
15064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
15065   void * jresult ;
15066   Dali::AngleAxis *arg1 = 0 ;
15067   Dali::Property::Value *result = 0 ;
15068
15069   arg1 = (Dali::AngleAxis *)jarg1;
15070   if (!arg1) {
15071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
15072     return 0;
15073   }
15074   {
15075     try {
15076       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
15077     } catch (std::out_of_range& e) {
15078       {
15079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15080       };
15081     } catch (std::exception& e) {
15082       {
15083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15084       };
15085     } catch (...) {
15086       {
15087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15088       };
15089     }
15090   }
15091   jresult = (void *)result;
15092   return jresult;
15093 }
15094
15095
15096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
15097   void * jresult ;
15098   Dali::Quaternion *arg1 = 0 ;
15099   Dali::Property::Value *result = 0 ;
15100
15101   arg1 = (Dali::Quaternion *)jarg1;
15102   if (!arg1) {
15103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
15104     return 0;
15105   }
15106   {
15107     try {
15108       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
15109     } catch (std::out_of_range& e) {
15110       {
15111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15112       };
15113     } catch (std::exception& e) {
15114       {
15115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15116       };
15117     } catch (...) {
15118       {
15119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15120       };
15121     }
15122   }
15123   jresult = (void *)result;
15124   return jresult;
15125 }
15126
15127
15128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
15129   void * jresult ;
15130   std::string *arg1 = 0 ;
15131   Dali::Property::Value *result = 0 ;
15132
15133   if (!jarg1) {
15134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15135     return 0;
15136   }
15137   std::string arg1_str(jarg1);
15138   arg1 = &arg1_str;
15139   {
15140     try {
15141       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
15142     } catch (std::out_of_range& e) {
15143       {
15144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15145       };
15146     } catch (std::exception& e) {
15147       {
15148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15149       };
15150     } catch (...) {
15151       {
15152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15153       };
15154     }
15155   }
15156   jresult = (void *)result;
15157
15158   //argout typemap for const std::string&
15159
15160   return jresult;
15161 }
15162
15163
15164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
15165   void * jresult ;
15166   Dali::Property::Array *arg1 = 0 ;
15167   Dali::Property::Value *result = 0 ;
15168
15169   arg1 = (Dali::Property::Array *)jarg1;
15170   if (!arg1) {
15171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15172     return 0;
15173   }
15174   {
15175     try {
15176       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15177     } catch (std::out_of_range& e) {
15178       {
15179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15180       };
15181     } catch (std::exception& e) {
15182       {
15183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15184       };
15185     } catch (...) {
15186       {
15187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15188       };
15189     }
15190   }
15191   jresult = (void *)result;
15192   return jresult;
15193 }
15194
15195
15196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
15197   void * jresult ;
15198   Dali::Property::Map *arg1 = 0 ;
15199   Dali::Property::Value *result = 0 ;
15200
15201   arg1 = (Dali::Property::Map *)jarg1;
15202   if (!arg1) {
15203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15204     return 0;
15205   }
15206   {
15207     try {
15208       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15209     } catch (std::out_of_range& e) {
15210       {
15211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15212       };
15213     } catch (std::exception& e) {
15214       {
15215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15216       };
15217     } catch (...) {
15218       {
15219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15220       };
15221     }
15222   }
15223   jresult = (void *)result;
15224   return jresult;
15225 }
15226
15227
15228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(int jarg1) {
15229   void * jresult ;
15230   Dali::Property::Type arg1 ;
15231   Dali::Property::Value *result = 0 ;
15232
15233   arg1 = (Dali::Property::Type)jarg1;
15234   {
15235     try {
15236       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
15237     } catch (std::out_of_range& e) {
15238       {
15239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15240       };
15241     } catch (std::exception& e) {
15242       {
15243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15244       };
15245     } catch (...) {
15246       {
15247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15248       };
15249     }
15250   }
15251   jresult = (void *)result;
15252   return jresult;
15253 }
15254
15255
15256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(void * jarg1) {
15257   void * jresult ;
15258   Dali::Property::Value *arg1 = 0 ;
15259   Dali::Property::Value *result = 0 ;
15260
15261   arg1 = (Dali::Property::Value *)jarg1;
15262   if (!arg1) {
15263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15264     return 0;
15265   }
15266   {
15267     try {
15268       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
15269     } catch (std::out_of_range& e) {
15270       {
15271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15272       };
15273     } catch (std::exception& e) {
15274       {
15275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15276       };
15277     } catch (...) {
15278       {
15279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15280       };
15281     }
15282   }
15283   jresult = (void *)result;
15284   return jresult;
15285 }
15286
15287
15288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
15289   void * jresult ;
15290   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15291   Dali::Property::Value *arg2 = 0 ;
15292   Dali::Property::Value *result = 0 ;
15293
15294   arg1 = (Dali::Property::Value *)jarg1;
15295   arg2 = (Dali::Property::Value *)jarg2;
15296   if (!arg2) {
15297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15298     return 0;
15299   }
15300   {
15301     try {
15302       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
15303     } catch (std::out_of_range& e) {
15304       {
15305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15306       };
15307     } catch (std::exception& e) {
15308       {
15309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15310       };
15311     } catch (...) {
15312       {
15313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15314       };
15315     }
15316   }
15317   jresult = (void *)result;
15318   return jresult;
15319 }
15320
15321
15322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
15323   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15324
15325   arg1 = (Dali::Property::Value *)jarg1;
15326   {
15327     try {
15328       delete arg1;
15329     } catch (std::out_of_range& e) {
15330       {
15331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15332       };
15333     } catch (std::exception& e) {
15334       {
15335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15336       };
15337     } catch (...) {
15338       {
15339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15340       };
15341     }
15342   }
15343 }
15344
15345
15346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
15347   int jresult ;
15348   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15349   Dali::Property::Type result;
15350
15351   arg1 = (Dali::Property::Value *)jarg1;
15352   {
15353     try {
15354       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
15355     } catch (std::out_of_range& e) {
15356       {
15357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15358       };
15359     } catch (std::exception& e) {
15360       {
15361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15362       };
15363     } catch (...) {
15364       {
15365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15366       };
15367     }
15368   }
15369   jresult = (int)result;
15370   return jresult;
15371 }
15372
15373
15374 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
15375   unsigned int jresult ;
15376   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15377   bool *arg2 = 0 ;
15378   bool result;
15379
15380   arg1 = (Dali::Property::Value *)jarg1;
15381   arg2 = (bool *)jarg2;
15382   {
15383     try {
15384       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15385     } catch (std::out_of_range& e) {
15386       {
15387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15388       };
15389     } catch (std::exception& e) {
15390       {
15391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15392       };
15393     } catch (...) {
15394       {
15395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15396       };
15397     }
15398   }
15399   jresult = result;
15400   return jresult;
15401 }
15402
15403
15404 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
15405   unsigned int jresult ;
15406   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15407   float *arg2 = 0 ;
15408   bool result;
15409
15410   arg1 = (Dali::Property::Value *)jarg1;
15411   arg2 = (float *)jarg2;
15412   {
15413     try {
15414       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15415     } catch (std::out_of_range& e) {
15416       {
15417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15418       };
15419     } catch (std::exception& e) {
15420       {
15421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15422       };
15423     } catch (...) {
15424       {
15425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15426       };
15427     }
15428   }
15429   jresult = result;
15430   return jresult;
15431 }
15432
15433
15434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
15435   unsigned int jresult ;
15436   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15437   int *arg2 = 0 ;
15438   bool result;
15439
15440   arg1 = (Dali::Property::Value *)jarg1;
15441   arg2 = (int *)jarg2;
15442   {
15443     try {
15444       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15445     } catch (std::out_of_range& e) {
15446       {
15447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15448       };
15449     } catch (std::exception& e) {
15450       {
15451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15452       };
15453     } catch (...) {
15454       {
15455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15456       };
15457     }
15458   }
15459   jresult = result;
15460   return jresult;
15461 }
15462
15463
15464 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
15465   unsigned int jresult ;
15466   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15467   Dali::Rect< int > *arg2 = 0 ;
15468   bool result;
15469
15470   arg1 = (Dali::Property::Value *)jarg1;
15471   arg2 = (Dali::Rect< int > *)jarg2;
15472   if (!arg2) {
15473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
15474     return 0;
15475   }
15476   {
15477     try {
15478       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15479     } catch (std::out_of_range& e) {
15480       {
15481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15482       };
15483     } catch (std::exception& e) {
15484       {
15485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15486       };
15487     } catch (...) {
15488       {
15489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15490       };
15491     }
15492   }
15493   jresult = result;
15494   return jresult;
15495 }
15496
15497
15498 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
15499   unsigned int jresult ;
15500   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15501   Dali::Vector2 *arg2 = 0 ;
15502   bool result;
15503
15504   arg1 = (Dali::Property::Value *)jarg1;
15505   arg2 = (Dali::Vector2 *)jarg2;
15506   if (!arg2) {
15507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
15508     return 0;
15509   }
15510   {
15511     try {
15512       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15513     } catch (std::out_of_range& e) {
15514       {
15515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15516       };
15517     } catch (std::exception& e) {
15518       {
15519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15520       };
15521     } catch (...) {
15522       {
15523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15524       };
15525     }
15526   }
15527   jresult = result;
15528   return jresult;
15529 }
15530
15531
15532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
15533   unsigned int jresult ;
15534   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15535   Dali::Vector3 *arg2 = 0 ;
15536   bool result;
15537
15538   arg1 = (Dali::Property::Value *)jarg1;
15539   arg2 = (Dali::Vector3 *)jarg2;
15540   if (!arg2) {
15541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
15542     return 0;
15543   }
15544   {
15545     try {
15546       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15547     } catch (std::out_of_range& e) {
15548       {
15549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15550       };
15551     } catch (std::exception& e) {
15552       {
15553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15554       };
15555     } catch (...) {
15556       {
15557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15558       };
15559     }
15560   }
15561   jresult = result;
15562   return jresult;
15563 }
15564
15565
15566 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
15567   unsigned int jresult ;
15568   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15569   Dali::Vector4 *arg2 = 0 ;
15570   bool result;
15571
15572   arg1 = (Dali::Property::Value *)jarg1;
15573   arg2 = (Dali::Vector4 *)jarg2;
15574   if (!arg2) {
15575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
15576     return 0;
15577   }
15578   {
15579     try {
15580       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15581     } catch (std::out_of_range& e) {
15582       {
15583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15584       };
15585     } catch (std::exception& e) {
15586       {
15587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15588       };
15589     } catch (...) {
15590       {
15591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15592       };
15593     }
15594   }
15595   jresult = result;
15596   return jresult;
15597 }
15598
15599
15600 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
15601   unsigned int jresult ;
15602   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15603   Dali::Matrix3 *arg2 = 0 ;
15604   bool result;
15605
15606   arg1 = (Dali::Property::Value *)jarg1;
15607   arg2 = (Dali::Matrix3 *)jarg2;
15608   if (!arg2) {
15609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
15610     return 0;
15611   }
15612   {
15613     try {
15614       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15615     } catch (std::out_of_range& e) {
15616       {
15617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15618       };
15619     } catch (std::exception& e) {
15620       {
15621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15622       };
15623     } catch (...) {
15624       {
15625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15626       };
15627     }
15628   }
15629   jresult = result;
15630   return jresult;
15631 }
15632
15633
15634 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
15635   unsigned int jresult ;
15636   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15637   Dali::Matrix *arg2 = 0 ;
15638   bool result;
15639
15640   arg1 = (Dali::Property::Value *)jarg1;
15641   arg2 = (Dali::Matrix *)jarg2;
15642   if (!arg2) {
15643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
15644     return 0;
15645   }
15646   {
15647     try {
15648       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15649     } catch (std::out_of_range& e) {
15650       {
15651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15652       };
15653     } catch (std::exception& e) {
15654       {
15655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15656       };
15657     } catch (...) {
15658       {
15659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15660       };
15661     }
15662   }
15663   jresult = result;
15664   return jresult;
15665 }
15666
15667
15668 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
15669   unsigned int jresult ;
15670   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15671   Dali::AngleAxis *arg2 = 0 ;
15672   bool result;
15673
15674   arg1 = (Dali::Property::Value *)jarg1;
15675   arg2 = (Dali::AngleAxis *)jarg2;
15676   if (!arg2) {
15677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
15678     return 0;
15679   }
15680   {
15681     try {
15682       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15683     } catch (std::out_of_range& e) {
15684       {
15685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15686       };
15687     } catch (std::exception& e) {
15688       {
15689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15690       };
15691     } catch (...) {
15692       {
15693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15694       };
15695     }
15696   }
15697   jresult = result;
15698   return jresult;
15699 }
15700
15701
15702 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
15703   unsigned int jresult ;
15704   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15705   Dali::Quaternion *arg2 = 0 ;
15706   bool result;
15707
15708   arg1 = (Dali::Property::Value *)jarg1;
15709   arg2 = (Dali::Quaternion *)jarg2;
15710   if (!arg2) {
15711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
15712     return 0;
15713   }
15714   {
15715     try {
15716       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15717     } catch (std::out_of_range& e) {
15718       {
15719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15720       };
15721     } catch (std::exception& e) {
15722       {
15723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15724       };
15725     } catch (...) {
15726       {
15727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15728       };
15729     }
15730   }
15731   jresult = result;
15732   return jresult;
15733 }
15734
15735
15736 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
15737   unsigned int jresult ;
15738   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15739   std::string *arg2 = 0 ;
15740   bool result;
15741
15742   arg1 = (Dali::Property::Value *)jarg1;
15743
15744   //typemap in
15745   std::string temp;
15746   arg2 = &temp;
15747
15748   {
15749     try {
15750       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15751     } catch (std::out_of_range& e) {
15752       {
15753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15754       };
15755     } catch (std::exception& e) {
15756       {
15757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15758       };
15759     } catch (...) {
15760       {
15761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15762       };
15763     }
15764   }
15765   jresult = result;
15766
15767   //Typemap argout in c++ file.
15768   //This will convert c++ string to c# string
15769   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
15770
15771   return jresult;
15772 }
15773
15774
15775 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
15776   unsigned int jresult ;
15777   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15778   Dali::Property::Array *arg2 = 0 ;
15779   bool result;
15780
15781   arg1 = (Dali::Property::Value *)jarg1;
15782   arg2 = (Dali::Property::Array *)jarg2;
15783   if (!arg2) {
15784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15785     return 0;
15786   }
15787   {
15788     try {
15789       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15790     } catch (std::out_of_range& e) {
15791       {
15792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15793       };
15794     } catch (std::exception& e) {
15795       {
15796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15797       };
15798     } catch (...) {
15799       {
15800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15801       };
15802     }
15803   }
15804   jresult = result;
15805   return jresult;
15806 }
15807
15808
15809 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
15810   unsigned int jresult ;
15811   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15812   Dali::Property::Map *arg2 = 0 ;
15813   bool result;
15814
15815   arg1 = (Dali::Property::Value *)jarg1;
15816   arg2 = (Dali::Property::Map *)jarg2;
15817   if (!arg2) {
15818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15819     return 0;
15820   }
15821   {
15822     try {
15823       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15824     } catch (std::out_of_range& e) {
15825       {
15826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15827       };
15828     } catch (std::exception& e) {
15829       {
15830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15831       };
15832     } catch (...) {
15833       {
15834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15835       };
15836     }
15837   }
15838   jresult = result;
15839   return jresult;
15840 }
15841
15842
15843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
15844   void * jresult ;
15845   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15846   Dali::Property::Array *result = 0 ;
15847
15848   arg1 = (Dali::Property::Value *)jarg1;
15849   {
15850     try {
15851       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
15852     } catch (std::out_of_range& e) {
15853       {
15854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15855       };
15856     } catch (std::exception& e) {
15857       {
15858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15859       };
15860     } catch (...) {
15861       {
15862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15863       };
15864     }
15865   }
15866   jresult = (void *)result;
15867   return jresult;
15868 }
15869
15870
15871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
15872   void * jresult ;
15873   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15874   Dali::Property::Map *result = 0 ;
15875
15876   arg1 = (Dali::Property::Value *)jarg1;
15877   {
15878     try {
15879       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
15880     } catch (std::out_of_range& e) {
15881       {
15882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15883       };
15884     } catch (std::exception& e) {
15885       {
15886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15887       };
15888     } catch (...) {
15889       {
15890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15891       };
15892     }
15893   }
15894   jresult = (void *)result;
15895   return jresult;
15896 }
15897
15898
15899 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
15900   char * jresult ;
15901   Dali::Property::Type arg1 ;
15902   char *result = 0 ;
15903
15904   arg1 = (Dali::Property::Type)jarg1;
15905   {
15906     try {
15907       result = (char *)Dali::PropertyTypes::GetName(arg1);
15908     } catch (std::out_of_range& e) {
15909       {
15910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15911       };
15912     } catch (std::exception& e) {
15913       {
15914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15915       };
15916     } catch (...) {
15917       {
15918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15919       };
15920     }
15921   }
15922   jresult = SWIG_csharp_string_callback((const char *)result);
15923   return jresult;
15924 }
15925
15926
15927 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
15928   unsigned int jresult ;
15929   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15930   std::string *arg2 = 0 ;
15931   Dali::Property::Map *arg3 = 0 ;
15932   bool result;
15933
15934   arg1 = (Dali::BaseObject *)jarg1;
15935   if (!jarg2) {
15936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15937     return 0;
15938   }
15939   std::string arg2_str(jarg2);
15940   arg2 = &arg2_str;
15941   arg3 = (Dali::Property::Map *)jarg3;
15942   if (!arg3) {
15943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15944     return 0;
15945   }
15946   {
15947     try {
15948       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
15949     } catch (std::out_of_range& e) {
15950       {
15951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15952       };
15953     } catch (std::exception& e) {
15954       {
15955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15956       };
15957     } catch (...) {
15958       {
15959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15960       };
15961     }
15962   }
15963   jresult = result;
15964
15965   //argout typemap for const std::string&
15966
15967   return jresult;
15968 }
15969
15970
15971 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
15972   char * jresult ;
15973   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15974   std::string *result = 0 ;
15975
15976   arg1 = (Dali::BaseObject *)jarg1;
15977   {
15978     try {
15979       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
15980     } catch (std::out_of_range& e) {
15981       {
15982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15983       };
15984     } catch (std::exception& e) {
15985       {
15986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15987       };
15988     } catch (...) {
15989       {
15990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15991       };
15992     }
15993   }
15994   jresult = SWIG_csharp_string_callback(result->c_str());
15995   return jresult;
15996 }
15997
15998
15999 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
16000   unsigned int jresult ;
16001   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16002   Dali::TypeInfo *arg2 = 0 ;
16003   bool result;
16004
16005   arg1 = (Dali::BaseObject *)jarg1;
16006   arg2 = (Dali::TypeInfo *)jarg2;
16007   if (!arg2) {
16008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16009     return 0;
16010   }
16011   {
16012     try {
16013       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
16014     } catch (std::out_of_range& e) {
16015       {
16016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16017       };
16018     } catch (std::exception& e) {
16019       {
16020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16021       };
16022     } catch (...) {
16023       {
16024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16025       };
16026     }
16027   }
16028   jresult = result;
16029   return jresult;
16030 }
16031
16032
16033 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
16034   unsigned int jresult ;
16035   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16036   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
16037   std::string *arg3 = 0 ;
16038   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
16039   bool result;
16040
16041   arg1 = (Dali::BaseObject *)jarg1;
16042   arg2 = (ConnectionTrackerInterface *)jarg2;
16043   if (!jarg3) {
16044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16045     return 0;
16046   }
16047   std::string arg3_str(jarg3);
16048   arg3 = &arg3_str;
16049   arg4 = (FunctorDelegate *)jarg4;
16050   {
16051     try {
16052       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
16053     } catch (std::out_of_range& e) {
16054       {
16055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16056       };
16057     } catch (std::exception& e) {
16058       {
16059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16060       };
16061     } catch (...) {
16062       {
16063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16064       };
16065     }
16066   }
16067   jresult = result;
16068
16069   //argout typemap for const std::string&
16070
16071   return jresult;
16072 }
16073
16074
16075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
16076   void * jresult ;
16077   Dali::BaseHandle *arg1 = 0 ;
16078   Dali::BaseObject *result = 0 ;
16079
16080   arg1 = (Dali::BaseHandle *)jarg1;
16081   if (!arg1) {
16082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16083     return 0;
16084   }
16085   {
16086     try {
16087       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
16088     } catch (std::out_of_range& e) {
16089       {
16090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16091       };
16092     } catch (std::exception& e) {
16093       {
16094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16095       };
16096     } catch (...) {
16097       {
16098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16099       };
16100     }
16101   }
16102   jresult = (void *)result;
16103   return jresult;
16104 }
16105
16106
16107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
16108   void * jresult ;
16109   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16110   Dali::BaseHandle *result = 0 ;
16111
16112   arg1 = (Dali::BaseObject *)jarg1;
16113   {
16114     try {
16115       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
16116     } catch (std::out_of_range& e) {
16117       {
16118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16119       };
16120     } catch (std::exception& e) {
16121       {
16122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16123       };
16124     } catch (...) {
16125       {
16126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16127       };
16128     }
16129   }
16130   jresult = (void *)result;
16131   return jresult;
16132 }
16133
16134
16135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
16136   void * jresult ;
16137   Dali::BaseHandle *result = 0 ;
16138
16139   {
16140     try {
16141       result = (Dali::BaseHandle *)new Dali::BaseHandle();
16142     } catch (std::out_of_range& e) {
16143       {
16144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16145       };
16146     } catch (std::exception& e) {
16147       {
16148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16149       };
16150     } catch (...) {
16151       {
16152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16153       };
16154     }
16155   }
16156   jresult = (void *)result;
16157   return jresult;
16158 }
16159
16160
16161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
16162   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16163
16164   arg1 = (Dali::BaseHandle *)jarg1;
16165   {
16166     try {
16167       delete arg1;
16168     } catch (std::out_of_range& e) {
16169       {
16170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16171       };
16172     } catch (std::exception& e) {
16173       {
16174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16175       };
16176     } catch (...) {
16177       {
16178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16179       };
16180     }
16181   }
16182 }
16183
16184
16185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
16186   void * jresult ;
16187   Dali::BaseHandle *arg1 = 0 ;
16188   Dali::BaseHandle *result = 0 ;
16189
16190   arg1 = (Dali::BaseHandle *)jarg1;
16191   if (!arg1) {
16192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16193     return 0;
16194   }
16195   {
16196     try {
16197       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
16198     } catch (std::out_of_range& e) {
16199       {
16200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16201       };
16202     } catch (std::exception& e) {
16203       {
16204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16205       };
16206     } catch (...) {
16207       {
16208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16209       };
16210     }
16211   }
16212   jresult = (void *)result;
16213   return jresult;
16214 }
16215
16216
16217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
16218   void * jresult ;
16219   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16220   Dali::BaseHandle *arg2 = 0 ;
16221   Dali::BaseHandle *result = 0 ;
16222
16223   arg1 = (Dali::BaseHandle *)jarg1;
16224   arg2 = (Dali::BaseHandle *)jarg2;
16225   if (!arg2) {
16226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16227     return 0;
16228   }
16229   {
16230     try {
16231       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
16232     } catch (std::out_of_range& e) {
16233       {
16234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16235       };
16236     } catch (std::exception& e) {
16237       {
16238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16239       };
16240     } catch (...) {
16241       {
16242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16243       };
16244     }
16245   }
16246   jresult = (void *)result;
16247   return jresult;
16248 }
16249
16250
16251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
16252   unsigned int jresult ;
16253   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16254   std::string *arg2 = 0 ;
16255   Dali::Property::Map *arg3 = 0 ;
16256   bool result;
16257
16258   arg1 = (Dali::BaseHandle *)jarg1;
16259   if (!jarg2) {
16260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16261     return 0;
16262   }
16263   std::string arg2_str(jarg2);
16264   arg2 = &arg2_str;
16265   arg3 = (Dali::Property::Map *)jarg3;
16266   if (!arg3) {
16267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16268     return 0;
16269   }
16270   {
16271     try {
16272       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
16273     } catch (std::out_of_range& e) {
16274       {
16275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16276       };
16277     } catch (std::exception& e) {
16278       {
16279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16280       };
16281     } catch (...) {
16282       {
16283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16284       };
16285     }
16286   }
16287   jresult = result;
16288
16289   //argout typemap for const std::string&
16290
16291   return jresult;
16292 }
16293
16294
16295 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
16296   char * jresult ;
16297   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16298   std::string *result = 0 ;
16299
16300   arg1 = (Dali::BaseHandle *)jarg1;
16301   {
16302     try {
16303       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
16304     } catch (std::out_of_range& e) {
16305       {
16306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16307       };
16308     } catch (std::exception& e) {
16309       {
16310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16311       };
16312     } catch (...) {
16313       {
16314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16315       };
16316     }
16317   }
16318   jresult = SWIG_csharp_string_callback(result->c_str());
16319   return jresult;
16320 }
16321
16322
16323 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
16324   unsigned int jresult ;
16325   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16326   Dali::TypeInfo *arg2 = 0 ;
16327   bool result;
16328
16329   arg1 = (Dali::BaseHandle *)jarg1;
16330   arg2 = (Dali::TypeInfo *)jarg2;
16331   if (!arg2) {
16332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16333     return 0;
16334   }
16335   {
16336     try {
16337       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
16338     } catch (std::out_of_range& e) {
16339       {
16340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16341       };
16342     } catch (std::exception& e) {
16343       {
16344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16345       };
16346     } catch (...) {
16347       {
16348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16349       };
16350     }
16351   }
16352   jresult = result;
16353   return jresult;
16354 }
16355
16356
16357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
16358   void * jresult ;
16359   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16360   Dali::BaseObject *result = 0 ;
16361
16362   arg1 = (Dali::BaseHandle *)jarg1;
16363   {
16364     try {
16365       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
16366     } catch (std::out_of_range& e) {
16367       {
16368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16369       };
16370     } catch (std::exception& e) {
16371       {
16372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16373       };
16374     } catch (...) {
16375       {
16376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16377       };
16378     }
16379   }
16380   jresult = (void *)result;
16381   return jresult;
16382 }
16383
16384
16385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
16386   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16387
16388   arg1 = (Dali::BaseHandle *)jarg1;
16389   {
16390     try {
16391       (arg1)->Reset();
16392     } catch (std::out_of_range& e) {
16393       {
16394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16395       };
16396     } catch (std::exception& e) {
16397       {
16398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16399       };
16400     } catch (...) {
16401       {
16402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16403       };
16404     }
16405   }
16406 }
16407
16408
16409 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
16410   unsigned int jresult ;
16411   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16412   Dali::BaseHandle *arg2 = 0 ;
16413   bool result;
16414
16415   arg1 = (Dali::BaseHandle *)jarg1;
16416   arg2 = (Dali::BaseHandle *)jarg2;
16417   if (!arg2) {
16418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16419     return 0;
16420   }
16421   {
16422     try {
16423       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
16424     } catch (std::out_of_range& e) {
16425       {
16426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16427       };
16428     } catch (std::exception& e) {
16429       {
16430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16431       };
16432     } catch (...) {
16433       {
16434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16435       };
16436     }
16437   }
16438   jresult = result;
16439   return jresult;
16440 }
16441
16442
16443 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
16444   unsigned int jresult ;
16445   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16446   Dali::BaseHandle *arg2 = 0 ;
16447   bool result;
16448
16449   arg1 = (Dali::BaseHandle *)jarg1;
16450   arg2 = (Dali::BaseHandle *)jarg2;
16451   if (!arg2) {
16452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16453     return 0;
16454   }
16455   {
16456     try {
16457       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
16458     } catch (std::out_of_range& e) {
16459       {
16460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16461       };
16462     } catch (std::exception& e) {
16463       {
16464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16465       };
16466     } catch (...) {
16467       {
16468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16469       };
16470     }
16471   }
16472   jresult = result;
16473   return jresult;
16474 }
16475
16476
16477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
16478   void * jresult ;
16479   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16480   Dali::RefObject *result = 0 ;
16481
16482   arg1 = (Dali::BaseHandle *)jarg1;
16483   {
16484     try {
16485       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
16486     } catch (std::out_of_range& e) {
16487       {
16488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16489       };
16490     } catch (std::exception& e) {
16491       {
16492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16493       };
16494     } catch (...) {
16495       {
16496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16497       };
16498     }
16499   }
16500   jresult = (void *)result;
16501   return jresult;
16502 }
16503
16504
16505 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
16506   unsigned int jresult ;
16507   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16508   bool result;
16509
16510   arg1 = (Dali::BaseHandle *)jarg1;
16511   {
16512     try {
16513       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
16514     } catch (std::out_of_range& e) {
16515       {
16516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16517       };
16518     } catch (std::exception& e) {
16519       {
16520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16521       };
16522     } catch (...) {
16523       {
16524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16525       };
16526     }
16527   }
16528   jresult = result;
16529   return jresult;
16530 }
16531
16532
16533 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
16534   unsigned int jresult ;
16535   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16536   Dali::BaseHandle *arg2 = 0 ;
16537   bool result;
16538
16539   arg1 = (Dali::BaseHandle *)jarg1;
16540   arg2 = (Dali::BaseHandle *)jarg2;
16541   if (!arg2) {
16542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16543     return 0;
16544   }
16545   {
16546     try {
16547       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
16548     } catch (std::out_of_range& e) {
16549       {
16550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16551       };
16552     } catch (std::exception& e) {
16553       {
16554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16555       };
16556     } catch (...) {
16557       {
16558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16559       };
16560     }
16561   }
16562   jresult = result;
16563   return jresult;
16564 }
16565
16566
16567 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
16568   unsigned int jresult ;
16569   Dali::BaseHandle *arg1 = 0 ;
16570   Dali::BaseHandle *arg2 = 0 ;
16571   bool result;
16572
16573   arg1 = (Dali::BaseHandle *)jarg1;
16574   if (!arg1) {
16575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16576     return 0;
16577   }
16578   arg2 = (Dali::BaseHandle *)jarg2;
16579   if (!arg2) {
16580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16581     return 0;
16582   }
16583   {
16584     try {
16585       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
16586     } catch (std::out_of_range& e) {
16587       {
16588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16589       };
16590     } catch (std::exception& e) {
16591       {
16592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16593       };
16594     } catch (...) {
16595       {
16596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16597       };
16598     }
16599   }
16600   jresult = result;
16601   return jresult;
16602 }
16603
16604
16605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
16606   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16607
16608   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16609   {
16610     try {
16611       delete arg1;
16612     } catch (std::out_of_range& e) {
16613       {
16614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16615       };
16616     } catch (std::exception& e) {
16617       {
16618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16619       };
16620     } catch (...) {
16621       {
16622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16623       };
16624     }
16625   }
16626 }
16627
16628
16629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16630   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16631   SlotObserver *arg2 = (SlotObserver *) 0 ;
16632   CallbackBase *arg3 = (CallbackBase *) 0 ;
16633
16634   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16635   arg2 = (SlotObserver *)jarg2;
16636   arg3 = (CallbackBase *)jarg3;
16637   {
16638     try {
16639       (arg1)->SignalConnected(arg2,arg3);
16640     } catch (std::out_of_range& e) {
16641       {
16642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16643       };
16644     } catch (std::exception& e) {
16645       {
16646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16647       };
16648     } catch (...) {
16649       {
16650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16651       };
16652     }
16653   }
16654 }
16655
16656
16657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
16658   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16659
16660   arg1 = (Dali::SignalObserver *)jarg1;
16661   {
16662     try {
16663       delete arg1;
16664     } catch (std::out_of_range& e) {
16665       {
16666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16667       };
16668     } catch (std::exception& e) {
16669       {
16670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16671       };
16672     } catch (...) {
16673       {
16674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16675       };
16676     }
16677   }
16678 }
16679
16680
16681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16682   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16683   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16684   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16685
16686   arg1 = (Dali::SignalObserver *)jarg1;
16687   arg2 = (Dali::SlotObserver *)jarg2;
16688   arg3 = (Dali::CallbackBase *)jarg3;
16689   {
16690     try {
16691       (arg1)->SignalDisconnected(arg2,arg3);
16692     } catch (std::out_of_range& e) {
16693       {
16694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16695       };
16696     } catch (std::exception& e) {
16697       {
16698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16699       };
16700     } catch (...) {
16701       {
16702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16703       };
16704     }
16705   }
16706 }
16707
16708
16709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
16710   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16711
16712   arg1 = (Dali::SlotObserver *)jarg1;
16713   {
16714     try {
16715       delete arg1;
16716     } catch (std::out_of_range& e) {
16717       {
16718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16719       };
16720     } catch (std::exception& e) {
16721       {
16722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16723       };
16724     } catch (...) {
16725       {
16726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16727       };
16728     }
16729   }
16730 }
16731
16732
16733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
16734   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16735   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
16736
16737   arg1 = (Dali::SlotObserver *)jarg1;
16738   arg2 = (Dali::CallbackBase *)jarg2;
16739   {
16740     try {
16741       (arg1)->SlotDisconnected(arg2);
16742     } catch (std::out_of_range& e) {
16743       {
16744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16745       };
16746     } catch (std::exception& e) {
16747       {
16748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16749       };
16750     } catch (...) {
16751       {
16752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16753       };
16754     }
16755   }
16756 }
16757
16758
16759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
16760   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16761
16762   arg1 = (Dali::ConnectionTracker *)jarg1;
16763   {
16764     try {
16765       delete arg1;
16766     } catch (std::out_of_range& e) {
16767       {
16768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16769       };
16770     } catch (std::exception& e) {
16771       {
16772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16773       };
16774     } catch (...) {
16775       {
16776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16777       };
16778     }
16779   }
16780 }
16781
16782
16783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
16784   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16785
16786   arg1 = (Dali::ConnectionTracker *)jarg1;
16787   {
16788     try {
16789       (arg1)->DisconnectAll();
16790     } catch (std::out_of_range& e) {
16791       {
16792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16793       };
16794     } catch (std::exception& e) {
16795       {
16796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16797       };
16798     } catch (...) {
16799       {
16800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16801       };
16802     }
16803   }
16804 }
16805
16806
16807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16808   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16809   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16810   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16811
16812   arg1 = (Dali::ConnectionTracker *)jarg1;
16813   arg2 = (Dali::SlotObserver *)jarg2;
16814   arg3 = (Dali::CallbackBase *)jarg3;
16815   {
16816     try {
16817       (arg1)->SignalConnected(arg2,arg3);
16818     } catch (std::out_of_range& e) {
16819       {
16820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16821       };
16822     } catch (std::exception& e) {
16823       {
16824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16825       };
16826     } catch (...) {
16827       {
16828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16829       };
16830     }
16831   }
16832 }
16833
16834
16835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16836   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16837   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16838   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16839
16840   arg1 = (Dali::ConnectionTracker *)jarg1;
16841   arg2 = (Dali::SlotObserver *)jarg2;
16842   arg3 = (Dali::CallbackBase *)jarg3;
16843   {
16844     try {
16845       (arg1)->SignalDisconnected(arg2,arg3);
16846     } catch (std::out_of_range& e) {
16847       {
16848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16849       };
16850     } catch (std::exception& e) {
16851       {
16852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16853       };
16854     } catch (...) {
16855       {
16856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16857       };
16858     }
16859   }
16860 }
16861
16862
16863 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
16864   unsigned long jresult ;
16865   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16866   std::size_t result;
16867
16868   arg1 = (Dali::ConnectionTracker *)jarg1;
16869   {
16870     try {
16871       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
16872     } catch (std::out_of_range& e) {
16873       {
16874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16875       };
16876     } catch (std::exception& e) {
16877       {
16878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16879       };
16880     } catch (...) {
16881       {
16882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16883       };
16884     }
16885   }
16886   jresult = (unsigned long)result;
16887   return jresult;
16888 }
16889
16890
16891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
16892   void * jresult ;
16893   Dali::ObjectRegistry *result = 0 ;
16894
16895   {
16896     try {
16897       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
16898     } catch (std::out_of_range& e) {
16899       {
16900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16901       };
16902     } catch (std::exception& e) {
16903       {
16904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16905       };
16906     } catch (...) {
16907       {
16908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16909       };
16910     }
16911   }
16912   jresult = (void *)result;
16913   return jresult;
16914 }
16915
16916
16917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
16918   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16919
16920   arg1 = (Dali::ObjectRegistry *)jarg1;
16921   {
16922     try {
16923       delete arg1;
16924     } catch (std::out_of_range& e) {
16925       {
16926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16927       };
16928     } catch (std::exception& e) {
16929       {
16930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16931       };
16932     } catch (...) {
16933       {
16934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16935       };
16936     }
16937   }
16938 }
16939
16940
16941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
16942   void * jresult ;
16943   Dali::ObjectRegistry *arg1 = 0 ;
16944   Dali::ObjectRegistry *result = 0 ;
16945
16946   arg1 = (Dali::ObjectRegistry *)jarg1;
16947   if (!arg1) {
16948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16949     return 0;
16950   }
16951   {
16952     try {
16953       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
16954     } catch (std::out_of_range& e) {
16955       {
16956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16957       };
16958     } catch (std::exception& e) {
16959       {
16960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16961       };
16962     } catch (...) {
16963       {
16964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16965       };
16966     }
16967   }
16968   jresult = (void *)result;
16969   return jresult;
16970 }
16971
16972
16973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
16974   void * jresult ;
16975   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16976   Dali::ObjectRegistry *arg2 = 0 ;
16977   Dali::ObjectRegistry *result = 0 ;
16978
16979   arg1 = (Dali::ObjectRegistry *)jarg1;
16980   arg2 = (Dali::ObjectRegistry *)jarg2;
16981   if (!arg2) {
16982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16983     return 0;
16984   }
16985   {
16986     try {
16987       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
16988     } catch (std::out_of_range& e) {
16989       {
16990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16991       };
16992     } catch (std::exception& e) {
16993       {
16994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16995       };
16996     } catch (...) {
16997       {
16998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16999       };
17000     }
17001   }
17002   jresult = (void *)result;
17003   return jresult;
17004 }
17005
17006
17007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
17008   void * jresult ;
17009   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
17010   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
17011
17012   arg1 = (Dali::ObjectRegistry *)jarg1;
17013   {
17014     try {
17015       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
17016     } catch (std::out_of_range& e) {
17017       {
17018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17019       };
17020     } catch (std::exception& e) {
17021       {
17022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17023       };
17024     } catch (...) {
17025       {
17026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17027       };
17028     }
17029   }
17030   jresult = (void *)result;
17031   return jresult;
17032 }
17033
17034
17035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
17036   void * jresult ;
17037   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
17038   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
17039
17040   arg1 = (Dali::ObjectRegistry *)jarg1;
17041   {
17042     try {
17043       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
17044     } catch (std::out_of_range& e) {
17045       {
17046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17047       };
17048     } catch (std::exception& e) {
17049       {
17050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17051       };
17052     } catch (...) {
17053       {
17054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17055       };
17056     }
17057   }
17058   jresult = (void *)result;
17059   return jresult;
17060 }
17061
17062
17063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
17064   void * jresult ;
17065   Dali::PropertyCondition *result = 0 ;
17066
17067   {
17068     try {
17069       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
17070     } catch (std::out_of_range& e) {
17071       {
17072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17073       };
17074     } catch (std::exception& e) {
17075       {
17076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17077       };
17078     } catch (...) {
17079       {
17080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17081       };
17082     }
17083   }
17084   jresult = (void *)result;
17085   return jresult;
17086 }
17087
17088
17089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
17090   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17091
17092   arg1 = (Dali::PropertyCondition *)jarg1;
17093   {
17094     try {
17095       delete arg1;
17096     } catch (std::out_of_range& e) {
17097       {
17098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17099       };
17100     } catch (std::exception& e) {
17101       {
17102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17103       };
17104     } catch (...) {
17105       {
17106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17107       };
17108     }
17109   }
17110 }
17111
17112
17113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
17114   void * jresult ;
17115   Dali::PropertyCondition *arg1 = 0 ;
17116   Dali::PropertyCondition *result = 0 ;
17117
17118   arg1 = (Dali::PropertyCondition *)jarg1;
17119   if (!arg1) {
17120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17121     return 0;
17122   }
17123   {
17124     try {
17125       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
17126     } catch (std::out_of_range& e) {
17127       {
17128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17129       };
17130     } catch (std::exception& e) {
17131       {
17132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17133       };
17134     } catch (...) {
17135       {
17136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17137       };
17138     }
17139   }
17140   jresult = (void *)result;
17141   return jresult;
17142 }
17143
17144
17145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
17146   void * jresult ;
17147   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17148   Dali::PropertyCondition *arg2 = 0 ;
17149   Dali::PropertyCondition *result = 0 ;
17150
17151   arg1 = (Dali::PropertyCondition *)jarg1;
17152   arg2 = (Dali::PropertyCondition *)jarg2;
17153   if (!arg2) {
17154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17155     return 0;
17156   }
17157   {
17158     try {
17159       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
17160     } catch (std::out_of_range& e) {
17161       {
17162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17163       };
17164     } catch (std::exception& e) {
17165       {
17166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17167       };
17168     } catch (...) {
17169       {
17170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17171       };
17172     }
17173   }
17174   jresult = (void *)result;
17175   return jresult;
17176 }
17177
17178
17179 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
17180   unsigned long jresult ;
17181   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17182   std::size_t result;
17183
17184   arg1 = (Dali::PropertyCondition *)jarg1;
17185   {
17186     try {
17187       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
17188     } catch (std::out_of_range& e) {
17189       {
17190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17191       };
17192     } catch (std::exception& e) {
17193       {
17194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17195       };
17196     } catch (...) {
17197       {
17198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17199       };
17200     }
17201   }
17202   jresult = (unsigned long)result;
17203   return jresult;
17204 }
17205
17206
17207 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
17208   float jresult ;
17209   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17210   std::size_t arg2 ;
17211   float result;
17212
17213   arg1 = (Dali::PropertyCondition *)jarg1;
17214   arg2 = (std::size_t)jarg2;
17215   {
17216     try {
17217       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
17218     } catch (std::out_of_range& e) {
17219       {
17220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17221       };
17222     } catch (std::exception& e) {
17223       {
17224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17225       };
17226     } catch (...) {
17227       {
17228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17229       };
17230     }
17231   }
17232   jresult = result;
17233   return jresult;
17234 }
17235
17236
17237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
17238   void * jresult ;
17239   float arg1 ;
17240   Dali::PropertyCondition result;
17241
17242   arg1 = (float)jarg1;
17243   {
17244     try {
17245       result = Dali::LessThanCondition(arg1);
17246     } catch (std::out_of_range& e) {
17247       {
17248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17249       };
17250     } catch (std::exception& e) {
17251       {
17252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17253       };
17254     } catch (...) {
17255       {
17256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17257       };
17258     }
17259   }
17260   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17261   return jresult;
17262 }
17263
17264
17265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
17266   void * jresult ;
17267   float arg1 ;
17268   Dali::PropertyCondition result;
17269
17270   arg1 = (float)jarg1;
17271   {
17272     try {
17273       result = Dali::GreaterThanCondition(arg1);
17274     } catch (std::out_of_range& e) {
17275       {
17276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17277       };
17278     } catch (std::exception& e) {
17279       {
17280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17281       };
17282     } catch (...) {
17283       {
17284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17285       };
17286     }
17287   }
17288   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17289   return jresult;
17290 }
17291
17292
17293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
17294   void * jresult ;
17295   float arg1 ;
17296   float arg2 ;
17297   Dali::PropertyCondition result;
17298
17299   arg1 = (float)jarg1;
17300   arg2 = (float)jarg2;
17301   {
17302     try {
17303       result = Dali::InsideCondition(arg1,arg2);
17304     } catch (std::out_of_range& e) {
17305       {
17306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17307       };
17308     } catch (std::exception& e) {
17309       {
17310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17311       };
17312     } catch (...) {
17313       {
17314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17315       };
17316     }
17317   }
17318   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17319   return jresult;
17320 }
17321
17322
17323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
17324   void * jresult ;
17325   float arg1 ;
17326   float arg2 ;
17327   Dali::PropertyCondition result;
17328
17329   arg1 = (float)jarg1;
17330   arg2 = (float)jarg2;
17331   {
17332     try {
17333       result = Dali::OutsideCondition(arg1,arg2);
17334     } catch (std::out_of_range& e) {
17335       {
17336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17337       };
17338     } catch (std::exception& e) {
17339       {
17340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17341       };
17342     } catch (...) {
17343       {
17344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17345       };
17346     }
17347   }
17348   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17349   return jresult;
17350 }
17351
17352
17353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
17354   void * jresult ;
17355   float arg1 ;
17356   float arg2 ;
17357   Dali::PropertyCondition result;
17358
17359   arg1 = (float)jarg1;
17360   arg2 = (float)jarg2;
17361   {
17362     try {
17363       result = Dali::StepCondition(arg1,arg2);
17364     } catch (std::out_of_range& e) {
17365       {
17366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17367       };
17368     } catch (std::exception& e) {
17369       {
17370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17371       };
17372     } catch (...) {
17373       {
17374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17375       };
17376     }
17377   }
17378   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17379   return jresult;
17380 }
17381
17382
17383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
17384   void * jresult ;
17385   float arg1 ;
17386   Dali::PropertyCondition result;
17387
17388   arg1 = (float)jarg1;
17389   {
17390     try {
17391       result = Dali::StepCondition(arg1);
17392     } catch (std::out_of_range& e) {
17393       {
17394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17395       };
17396     } catch (std::exception& e) {
17397       {
17398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17399       };
17400     } catch (...) {
17401       {
17402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17403       };
17404     }
17405   }
17406   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17407   return jresult;
17408 }
17409
17410
17411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
17412   void * jresult ;
17413   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
17414   Dali::PropertyCondition result;
17415
17416   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
17417   if (!arg1) {
17418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
17419     return 0;
17420   }
17421   {
17422     try {
17423       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
17424     } catch (std::out_of_range& e) {
17425       {
17426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17427       };
17428     } catch (std::exception& e) {
17429       {
17430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17431       };
17432     } catch (...) {
17433       {
17434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17435       };
17436     }
17437   }
17438   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17439   return jresult;
17440 }
17441
17442
17443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
17444   void * jresult ;
17445   Dali::PropertyNotification *result = 0 ;
17446
17447   {
17448     try {
17449       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
17450     } catch (std::out_of_range& e) {
17451       {
17452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17453       };
17454     } catch (std::exception& e) {
17455       {
17456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17457       };
17458     } catch (...) {
17459       {
17460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17461       };
17462     }
17463   }
17464   jresult = (void *)result;
17465   return jresult;
17466 }
17467
17468
17469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
17470   void * jresult ;
17471   Dali::BaseHandle arg1 ;
17472   Dali::BaseHandle *argp1 ;
17473   Dali::PropertyNotification result;
17474
17475   argp1 = (Dali::BaseHandle *)jarg1;
17476   if (!argp1) {
17477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17478     return 0;
17479   }
17480   arg1 = *argp1;
17481   {
17482     try {
17483       result = Dali::PropertyNotification::DownCast(arg1);
17484     } catch (std::out_of_range& e) {
17485       {
17486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17487       };
17488     } catch (std::exception& e) {
17489       {
17490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17491       };
17492     } catch (...) {
17493       {
17494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17495       };
17496     }
17497   }
17498   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
17499   return jresult;
17500 }
17501
17502
17503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
17504   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17505
17506   arg1 = (Dali::PropertyNotification *)jarg1;
17507   {
17508     try {
17509       delete arg1;
17510     } catch (std::out_of_range& e) {
17511       {
17512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17513       };
17514     } catch (std::exception& e) {
17515       {
17516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17517       };
17518     } catch (...) {
17519       {
17520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17521       };
17522     }
17523   }
17524 }
17525
17526
17527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
17528   void * jresult ;
17529   Dali::PropertyNotification *arg1 = 0 ;
17530   Dali::PropertyNotification *result = 0 ;
17531
17532   arg1 = (Dali::PropertyNotification *)jarg1;
17533   if (!arg1) {
17534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17535     return 0;
17536   }
17537   {
17538     try {
17539       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
17540     } catch (std::out_of_range& e) {
17541       {
17542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17543       };
17544     } catch (std::exception& e) {
17545       {
17546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17547       };
17548     } catch (...) {
17549       {
17550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17551       };
17552     }
17553   }
17554   jresult = (void *)result;
17555   return jresult;
17556 }
17557
17558
17559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
17560   void * jresult ;
17561   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17562   Dali::PropertyNotification *arg2 = 0 ;
17563   Dali::PropertyNotification *result = 0 ;
17564
17565   arg1 = (Dali::PropertyNotification *)jarg1;
17566   arg2 = (Dali::PropertyNotification *)jarg2;
17567   if (!arg2) {
17568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17569     return 0;
17570   }
17571   {
17572     try {
17573       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
17574     } catch (std::out_of_range& e) {
17575       {
17576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17577       };
17578     } catch (std::exception& e) {
17579       {
17580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17581       };
17582     } catch (...) {
17583       {
17584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17585       };
17586     }
17587   }
17588   jresult = (void *)result;
17589   return jresult;
17590 }
17591
17592
17593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
17594   void * jresult ;
17595   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17596   Dali::PropertyCondition result;
17597
17598   arg1 = (Dali::PropertyNotification *)jarg1;
17599   {
17600     try {
17601       result = (arg1)->GetCondition();
17602     } catch (std::out_of_range& e) {
17603       {
17604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17605       };
17606     } catch (std::exception& e) {
17607       {
17608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17609       };
17610     } catch (...) {
17611       {
17612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17613       };
17614     }
17615   }
17616   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17617   return jresult;
17618 }
17619
17620
17621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
17622   void * jresult ;
17623   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17624   Dali::Handle result;
17625
17626   arg1 = (Dali::PropertyNotification *)jarg1;
17627   {
17628     try {
17629       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
17630     } catch (std::out_of_range& e) {
17631       {
17632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17633       };
17634     } catch (std::exception& e) {
17635       {
17636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17637       };
17638     } catch (...) {
17639       {
17640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17641       };
17642     }
17643   }
17644   jresult = new Dali::Handle((const Dali::Handle &)result);
17645   return jresult;
17646 }
17647
17648
17649 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
17650   int jresult ;
17651   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17652   Dali::Property::Index result;
17653
17654   arg1 = (Dali::PropertyNotification *)jarg1;
17655   {
17656     try {
17657       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
17658     } catch (std::out_of_range& e) {
17659       {
17660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17661       };
17662     } catch (std::exception& e) {
17663       {
17664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17665       };
17666     } catch (...) {
17667       {
17668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17669       };
17670     }
17671   }
17672   jresult = result;
17673   return jresult;
17674 }
17675
17676
17677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
17678   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17679   Dali::PropertyNotification::NotifyMode arg2 ;
17680
17681   arg1 = (Dali::PropertyNotification *)jarg1;
17682   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
17683   {
17684     try {
17685       (arg1)->SetNotifyMode(arg2);
17686     } catch (std::out_of_range& e) {
17687       {
17688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17689       };
17690     } catch (std::exception& e) {
17691       {
17692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17693       };
17694     } catch (...) {
17695       {
17696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17697       };
17698     }
17699   }
17700 }
17701
17702
17703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
17704   int jresult ;
17705   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17706   Dali::PropertyNotification::NotifyMode result;
17707
17708   arg1 = (Dali::PropertyNotification *)jarg1;
17709   {
17710     try {
17711       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
17712     } catch (std::out_of_range& e) {
17713       {
17714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17715       };
17716     } catch (std::exception& e) {
17717       {
17718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17719       };
17720     } catch (...) {
17721       {
17722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17723       };
17724     }
17725   }
17726   jresult = (int)result;
17727   return jresult;
17728 }
17729
17730
17731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
17732   unsigned int jresult ;
17733   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17734   bool result;
17735
17736   arg1 = (Dali::PropertyNotification *)jarg1;
17737   {
17738     try {
17739       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
17740     } catch (std::out_of_range& e) {
17741       {
17742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17743       };
17744     } catch (std::exception& e) {
17745       {
17746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17747       };
17748     } catch (...) {
17749       {
17750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17751       };
17752     }
17753   }
17754   jresult = result;
17755   return jresult;
17756 }
17757
17758
17759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
17760   void * jresult ;
17761   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17762   Dali::PropertyNotifySignalType *result = 0 ;
17763
17764   arg1 = (Dali::PropertyNotification *)jarg1;
17765   {
17766     try {
17767       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
17768     } catch (std::out_of_range& e) {
17769       {
17770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17771       };
17772     } catch (std::exception& e) {
17773       {
17774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17775       };
17776     } catch (...) {
17777       {
17778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17779       };
17780     }
17781   }
17782   jresult = (void *)result;
17783   return jresult;
17784 }
17785
17786
17787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
17788   void * jresult ;
17789   Dali::Handle *result = 0 ;
17790
17791   {
17792     try {
17793       result = (Dali::Handle *)new Dali::Handle();
17794     } catch (std::out_of_range& e) {
17795       {
17796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17797       };
17798     } catch (std::exception& e) {
17799       {
17800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17801       };
17802     } catch (...) {
17803       {
17804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17805       };
17806     }
17807   }
17808   jresult = (void *)result;
17809   return jresult;
17810 }
17811
17812
17813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
17814   void * jresult ;
17815   Dali::Handle result;
17816
17817   {
17818     try {
17819       result = Dali::Handle::New();
17820     } catch (std::out_of_range& e) {
17821       {
17822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17823       };
17824     } catch (std::exception& e) {
17825       {
17826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17827       };
17828     } catch (...) {
17829       {
17830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17831       };
17832     }
17833   }
17834   jresult = new Dali::Handle((const Dali::Handle &)result);
17835   return jresult;
17836 }
17837
17838
17839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
17840   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17841
17842   arg1 = (Dali::Handle *)jarg1;
17843   {
17844     try {
17845       delete arg1;
17846     } catch (std::out_of_range& e) {
17847       {
17848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17849       };
17850     } catch (std::exception& e) {
17851       {
17852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17853       };
17854     } catch (...) {
17855       {
17856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17857       };
17858     }
17859   }
17860 }
17861
17862
17863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
17864   void * jresult ;
17865   Dali::Handle *arg1 = 0 ;
17866   Dali::Handle *result = 0 ;
17867
17868   arg1 = (Dali::Handle *)jarg1;
17869   if (!arg1) {
17870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17871     return 0;
17872   }
17873   {
17874     try {
17875       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
17876     } catch (std::out_of_range& e) {
17877       {
17878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17879       };
17880     } catch (std::exception& e) {
17881       {
17882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17883       };
17884     } catch (...) {
17885       {
17886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17887       };
17888     }
17889   }
17890   jresult = (void *)result;
17891   return jresult;
17892 }
17893
17894
17895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
17896   void * jresult ;
17897   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17898   Dali::Handle *arg2 = 0 ;
17899   Dali::Handle *result = 0 ;
17900
17901   arg1 = (Dali::Handle *)jarg1;
17902   arg2 = (Dali::Handle *)jarg2;
17903   if (!arg2) {
17904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17905     return 0;
17906   }
17907   {
17908     try {
17909       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
17910     } catch (std::out_of_range& e) {
17911       {
17912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17913       };
17914     } catch (std::exception& e) {
17915       {
17916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17917       };
17918     } catch (...) {
17919       {
17920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17921       };
17922     }
17923   }
17924   jresult = (void *)result;
17925   return jresult;
17926 }
17927
17928
17929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
17930   void * jresult ;
17931   Dali::BaseHandle arg1 ;
17932   Dali::BaseHandle *argp1 ;
17933   Dali::Handle result;
17934
17935   argp1 = (Dali::BaseHandle *)jarg1;
17936   if (!argp1) {
17937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17938     return 0;
17939   }
17940   arg1 = *argp1;
17941   {
17942     try {
17943       result = Dali::Handle::DownCast(arg1);
17944     } catch (std::out_of_range& e) {
17945       {
17946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17947       };
17948     } catch (std::exception& e) {
17949       {
17950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17951       };
17952     } catch (...) {
17953       {
17954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17955       };
17956     }
17957   }
17958   jresult = new Dali::Handle((const Dali::Handle &)result);
17959   return jresult;
17960 }
17961
17962
17963 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
17964   unsigned int jresult ;
17965   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17966   Dali::Handle::Capability arg2 ;
17967   bool result;
17968
17969   arg1 = (Dali::Handle *)jarg1;
17970   arg2 = (Dali::Handle::Capability)jarg2;
17971   {
17972     try {
17973       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
17974     } catch (std::out_of_range& e) {
17975       {
17976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17977       };
17978     } catch (std::exception& e) {
17979       {
17980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17981       };
17982     } catch (...) {
17983       {
17984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17985       };
17986     }
17987   }
17988   jresult = result;
17989   return jresult;
17990 }
17991
17992
17993 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
17994   unsigned int jresult ;
17995   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17996   unsigned int result;
17997
17998   arg1 = (Dali::Handle *)jarg1;
17999   {
18000     try {
18001       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
18002     } catch (std::out_of_range& e) {
18003       {
18004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18005       };
18006     } catch (std::exception& e) {
18007       {
18008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18009       };
18010     } catch (...) {
18011       {
18012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18013       };
18014     }
18015   }
18016   jresult = result;
18017   return jresult;
18018 }
18019
18020
18021 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
18022   char * jresult ;
18023   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18024   Dali::Property::Index arg2 ;
18025   std::string result;
18026
18027   arg1 = (Dali::Handle *)jarg1;
18028   arg2 = (Dali::Property::Index)jarg2;
18029   {
18030     try {
18031       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
18032     } catch (std::out_of_range& e) {
18033       {
18034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18035       };
18036     } catch (std::exception& e) {
18037       {
18038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18039       };
18040     } catch (...) {
18041       {
18042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18043       };
18044     }
18045   }
18046   jresult = SWIG_csharp_string_callback((&result)->c_str());
18047   return jresult;
18048 }
18049
18050
18051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
18052   int jresult ;
18053   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18054   std::string *arg2 = 0 ;
18055   Dali::Property::Index result;
18056
18057   arg1 = (Dali::Handle *)jarg1;
18058   if (!jarg2) {
18059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18060     return 0;
18061   }
18062   std::string arg2_str(jarg2);
18063   arg2 = &arg2_str;
18064   {
18065     try {
18066       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
18067     } catch (std::out_of_range& e) {
18068       {
18069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18070       };
18071     } catch (std::exception& e) {
18072       {
18073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18074       };
18075     } catch (...) {
18076       {
18077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18078       };
18079     }
18080   }
18081   jresult = result;
18082
18083   //argout typemap for const std::string&
18084
18085   return jresult;
18086 }
18087
18088
18089 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
18090   unsigned int jresult ;
18091   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18092   Dali::Property::Index arg2 ;
18093   bool result;
18094
18095   arg1 = (Dali::Handle *)jarg1;
18096   arg2 = (Dali::Property::Index)jarg2;
18097   {
18098     try {
18099       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
18100     } catch (std::out_of_range& e) {
18101       {
18102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18103       };
18104     } catch (std::exception& e) {
18105       {
18106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18107       };
18108     } catch (...) {
18109       {
18110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18111       };
18112     }
18113   }
18114   jresult = result;
18115   return jresult;
18116 }
18117
18118
18119 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
18120   unsigned int jresult ;
18121   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18122   Dali::Property::Index arg2 ;
18123   bool result;
18124
18125   arg1 = (Dali::Handle *)jarg1;
18126   arg2 = (Dali::Property::Index)jarg2;
18127   {
18128     try {
18129       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
18130     } catch (std::out_of_range& e) {
18131       {
18132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18133       };
18134     } catch (std::exception& e) {
18135       {
18136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18137       };
18138     } catch (...) {
18139       {
18140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18141       };
18142     }
18143   }
18144   jresult = result;
18145   return jresult;
18146 }
18147
18148
18149 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
18150   unsigned int jresult ;
18151   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18152   Dali::Property::Index arg2 ;
18153   bool result;
18154
18155   arg1 = (Dali::Handle *)jarg1;
18156   arg2 = (Dali::Property::Index)jarg2;
18157   {
18158     try {
18159       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
18160     } catch (std::out_of_range& e) {
18161       {
18162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18163       };
18164     } catch (std::exception& e) {
18165       {
18166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18167       };
18168     } catch (...) {
18169       {
18170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18171       };
18172     }
18173   }
18174   jresult = result;
18175   return jresult;
18176 }
18177
18178
18179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
18180   int jresult ;
18181   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18182   Dali::Property::Index arg2 ;
18183   Dali::Property::Type result;
18184
18185   arg1 = (Dali::Handle *)jarg1;
18186   arg2 = (Dali::Property::Index)jarg2;
18187   {
18188     try {
18189       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
18190     } catch (std::out_of_range& e) {
18191       {
18192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18193       };
18194     } catch (std::exception& e) {
18195       {
18196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18197       };
18198     } catch (...) {
18199       {
18200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18201       };
18202     }
18203   }
18204   jresult = (int)result;
18205   return jresult;
18206 }
18207
18208
18209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
18210   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18211   Dali::Property::Index arg2 ;
18212   Dali::Property::Value *arg3 = 0 ;
18213
18214   arg1 = (Dali::Handle *)jarg1;
18215   arg2 = (Dali::Property::Index)jarg2;
18216   arg3 = (Dali::Property::Value *)jarg3;
18217   if (!arg3) {
18218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18219     return ;
18220   }
18221   {
18222     try {
18223       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
18224     } catch (std::out_of_range& e) {
18225       {
18226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18227       };
18228     } catch (std::exception& e) {
18229       {
18230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18231       };
18232     } catch (...) {
18233       {
18234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18235       };
18236     }
18237   }
18238 }
18239
18240
18241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
18242   int jresult ;
18243   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18244   std::string *arg2 = 0 ;
18245   Dali::Property::Value *arg3 = 0 ;
18246   Dali::Property::Index result;
18247
18248   arg1 = (Dali::Handle *)jarg1;
18249   if (!jarg2) {
18250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18251     return 0;
18252   }
18253   std::string arg2_str(jarg2);
18254   arg2 = &arg2_str;
18255   arg3 = (Dali::Property::Value *)jarg3;
18256   if (!arg3) {
18257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18258     return 0;
18259   }
18260   {
18261     try {
18262       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
18263     } catch (std::out_of_range& e) {
18264       {
18265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18266       };
18267     } catch (std::exception& e) {
18268       {
18269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18270       };
18271     } catch (...) {
18272       {
18273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18274       };
18275     }
18276   }
18277   jresult = result;
18278
18279   //argout typemap for const std::string&
18280
18281   return jresult;
18282 }
18283
18284
18285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
18286   int jresult ;
18287   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18288   std::string *arg2 = 0 ;
18289   Dali::Property::Value *arg3 = 0 ;
18290   Dali::Property::AccessMode arg4 ;
18291   Dali::Property::Index result;
18292
18293   arg1 = (Dali::Handle *)jarg1;
18294   if (!jarg2) {
18295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18296     return 0;
18297   }
18298   std::string arg2_str(jarg2);
18299   arg2 = &arg2_str;
18300   arg3 = (Dali::Property::Value *)jarg3;
18301   if (!arg3) {
18302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18303     return 0;
18304   }
18305   arg4 = (Dali::Property::AccessMode)jarg4;
18306   {
18307     try {
18308       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
18309     } catch (std::out_of_range& e) {
18310       {
18311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18312       };
18313     } catch (std::exception& e) {
18314       {
18315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18316       };
18317     } catch (...) {
18318       {
18319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18320       };
18321     }
18322   }
18323   jresult = result;
18324
18325   //argout typemap for const std::string&
18326
18327   return jresult;
18328 }
18329
18330
18331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
18332   void * jresult ;
18333   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18334   Dali::Property::Index arg2 ;
18335   Dali::Property::Value result;
18336
18337   arg1 = (Dali::Handle *)jarg1;
18338   arg2 = (Dali::Property::Index)jarg2;
18339   {
18340     try {
18341       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
18342     } catch (std::out_of_range& e) {
18343       {
18344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18345       };
18346     } catch (std::exception& e) {
18347       {
18348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18349       };
18350     } catch (...) {
18351       {
18352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18353       };
18354     }
18355   }
18356   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
18357   return jresult;
18358 }
18359
18360
18361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
18362   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18363   Dali::Property::IndexContainer *arg2 = 0 ;
18364
18365   arg1 = (Dali::Handle *)jarg1;
18366   arg2 = (Dali::Property::IndexContainer *)jarg2;
18367   if (!arg2) {
18368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18369     return ;
18370   }
18371   {
18372     try {
18373       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
18374     } catch (std::out_of_range& e) {
18375       {
18376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18377       };
18378     } catch (std::exception& e) {
18379       {
18380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18381       };
18382     } catch (...) {
18383       {
18384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18385       };
18386     }
18387   }
18388 }
18389
18390
18391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
18392   void * jresult ;
18393   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18394   Dali::Property::Index arg2 ;
18395   Dali::PropertyCondition *arg3 = 0 ;
18396   Dali::PropertyNotification result;
18397
18398   arg1 = (Dali::Handle *)jarg1;
18399   arg2 = (Dali::Property::Index)jarg2;
18400   arg3 = (Dali::PropertyCondition *)jarg3;
18401   if (!arg3) {
18402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18403     return 0;
18404   }
18405   {
18406     try {
18407       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
18408     } catch (std::out_of_range& e) {
18409       {
18410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18411       };
18412     } catch (std::exception& e) {
18413       {
18414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18415       };
18416     } catch (...) {
18417       {
18418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18419       };
18420     }
18421   }
18422   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18423   return jresult;
18424 }
18425
18426
18427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
18428   void * jresult ;
18429   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18430   Dali::Property::Index arg2 ;
18431   int arg3 ;
18432   Dali::PropertyCondition *arg4 = 0 ;
18433   Dali::PropertyNotification result;
18434
18435   arg1 = (Dali::Handle *)jarg1;
18436   arg2 = (Dali::Property::Index)jarg2;
18437   arg3 = (int)jarg3;
18438   arg4 = (Dali::PropertyCondition *)jarg4;
18439   if (!arg4) {
18440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18441     return 0;
18442   }
18443   {
18444     try {
18445       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
18446     } catch (std::out_of_range& e) {
18447       {
18448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18449       };
18450     } catch (std::exception& e) {
18451       {
18452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18453       };
18454     } catch (...) {
18455       {
18456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18457       };
18458     }
18459   }
18460   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18461   return jresult;
18462 }
18463
18464
18465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
18466   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18467   Dali::PropertyNotification arg2 ;
18468   Dali::PropertyNotification *argp2 ;
18469
18470   arg1 = (Dali::Handle *)jarg1;
18471   argp2 = (Dali::PropertyNotification *)jarg2;
18472   if (!argp2) {
18473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
18474     return ;
18475   }
18476   arg2 = *argp2;
18477   {
18478     try {
18479       (arg1)->RemovePropertyNotification(arg2);
18480     } catch (std::out_of_range& e) {
18481       {
18482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18483       };
18484     } catch (std::exception& e) {
18485       {
18486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18487       };
18488     } catch (...) {
18489       {
18490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18491       };
18492     }
18493   }
18494 }
18495
18496
18497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
18498   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18499
18500   arg1 = (Dali::Handle *)jarg1;
18501   {
18502     try {
18503       (arg1)->RemovePropertyNotifications();
18504     } catch (std::out_of_range& e) {
18505       {
18506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18507       };
18508     } catch (std::exception& e) {
18509       {
18510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18511       };
18512     } catch (...) {
18513       {
18514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18515       };
18516     }
18517   }
18518 }
18519
18520
18521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
18522   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18523
18524   arg1 = (Dali::Handle *)jarg1;
18525   {
18526     try {
18527       (arg1)->RemoveConstraints();
18528     } catch (std::out_of_range& e) {
18529       {
18530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18531       };
18532     } catch (std::exception& e) {
18533       {
18534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18535       };
18536     } catch (...) {
18537       {
18538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18539       };
18540     }
18541   }
18542 }
18543
18544
18545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
18546   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18547   unsigned int arg2 ;
18548
18549   arg1 = (Dali::Handle *)jarg1;
18550   arg2 = (unsigned int)jarg2;
18551   {
18552     try {
18553       (arg1)->RemoveConstraints(arg2);
18554     } catch (std::out_of_range& e) {
18555       {
18556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18557       };
18558     } catch (std::exception& e) {
18559       {
18560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18561       };
18562     } catch (...) {
18563       {
18564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18565       };
18566     }
18567   }
18568 }
18569
18570
18571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
18572   int jresult ;
18573   Dali::Property::Index result;
18574
18575   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
18576   jresult = result;
18577   return jresult;
18578 }
18579
18580
18581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
18582   void * jresult ;
18583   Dali::Handle result;
18584
18585   {
18586     try {
18587       result = Dali::WeightObject::New();
18588     } catch (std::out_of_range& e) {
18589       {
18590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18591       };
18592     } catch (std::exception& e) {
18593       {
18594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18595       };
18596     } catch (...) {
18597       {
18598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18599       };
18600     }
18601   }
18602   jresult = new Dali::Handle((const Dali::Handle &)result);
18603   return jresult;
18604 }
18605
18606
18607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
18608   void * jresult ;
18609   Dali::TypeInfo *result = 0 ;
18610
18611   {
18612     try {
18613       result = (Dali::TypeInfo *)new Dali::TypeInfo();
18614     } catch (std::out_of_range& e) {
18615       {
18616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18617       };
18618     } catch (std::exception& e) {
18619       {
18620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18621       };
18622     } catch (...) {
18623       {
18624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18625       };
18626     }
18627   }
18628   jresult = (void *)result;
18629   return jresult;
18630 }
18631
18632
18633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
18634   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18635
18636   arg1 = (Dali::TypeInfo *)jarg1;
18637   {
18638     try {
18639       delete arg1;
18640     } catch (std::out_of_range& e) {
18641       {
18642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18643       };
18644     } catch (std::exception& e) {
18645       {
18646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18647       };
18648     } catch (...) {
18649       {
18650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18651       };
18652     }
18653   }
18654 }
18655
18656
18657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
18658   void * jresult ;
18659   Dali::TypeInfo *arg1 = 0 ;
18660   Dali::TypeInfo *result = 0 ;
18661
18662   arg1 = (Dali::TypeInfo *)jarg1;
18663   if (!arg1) {
18664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18665     return 0;
18666   }
18667   {
18668     try {
18669       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
18670     } catch (std::out_of_range& e) {
18671       {
18672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18673       };
18674     } catch (std::exception& e) {
18675       {
18676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18677       };
18678     } catch (...) {
18679       {
18680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18681       };
18682     }
18683   }
18684   jresult = (void *)result;
18685   return jresult;
18686 }
18687
18688
18689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
18690   void * jresult ;
18691   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18692   Dali::TypeInfo *arg2 = 0 ;
18693   Dali::TypeInfo *result = 0 ;
18694
18695   arg1 = (Dali::TypeInfo *)jarg1;
18696   arg2 = (Dali::TypeInfo *)jarg2;
18697   if (!arg2) {
18698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18699     return 0;
18700   }
18701   {
18702     try {
18703       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
18704     } catch (std::out_of_range& e) {
18705       {
18706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18707       };
18708     } catch (std::exception& e) {
18709       {
18710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18711       };
18712     } catch (...) {
18713       {
18714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18715       };
18716     }
18717   }
18718   jresult = (void *)result;
18719   return jresult;
18720 }
18721
18722
18723 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
18724   char * jresult ;
18725   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18726   std::string *result = 0 ;
18727
18728   arg1 = (Dali::TypeInfo *)jarg1;
18729   {
18730     try {
18731       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
18732     } catch (std::out_of_range& e) {
18733       {
18734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18735       };
18736     } catch (std::exception& e) {
18737       {
18738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18739       };
18740     } catch (...) {
18741       {
18742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18743       };
18744     }
18745   }
18746   jresult = SWIG_csharp_string_callback(result->c_str());
18747   return jresult;
18748 }
18749
18750
18751 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
18752   char * jresult ;
18753   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18754   std::string *result = 0 ;
18755
18756   arg1 = (Dali::TypeInfo *)jarg1;
18757   {
18758     try {
18759       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
18760     } catch (std::out_of_range& e) {
18761       {
18762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18763       };
18764     } catch (std::exception& e) {
18765       {
18766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18767       };
18768     } catch (...) {
18769       {
18770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18771       };
18772     }
18773   }
18774   jresult = SWIG_csharp_string_callback(result->c_str());
18775   return jresult;
18776 }
18777
18778
18779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
18780   void * jresult ;
18781   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18782   Dali::BaseHandle result;
18783
18784   arg1 = (Dali::TypeInfo *)jarg1;
18785   {
18786     try {
18787       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
18788     } catch (std::out_of_range& e) {
18789       {
18790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18791       };
18792     } catch (std::exception& e) {
18793       {
18794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18795       };
18796     } catch (...) {
18797       {
18798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18799       };
18800     }
18801   }
18802   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
18803   return jresult;
18804 }
18805
18806
18807 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
18808   unsigned long jresult ;
18809   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18810   size_t result;
18811
18812   arg1 = (Dali::TypeInfo *)jarg1;
18813   {
18814     try {
18815       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
18816     } catch (std::out_of_range& e) {
18817       {
18818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18819       };
18820     } catch (std::exception& e) {
18821       {
18822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18823       };
18824     } catch (...) {
18825       {
18826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18827       };
18828     }
18829   }
18830   jresult = (unsigned long)result;
18831   return jresult;
18832 }
18833
18834
18835 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
18836   char * jresult ;
18837   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18838   size_t arg2 ;
18839   std::string result;
18840
18841   arg1 = (Dali::TypeInfo *)jarg1;
18842   arg2 = (size_t)jarg2;
18843   {
18844     try {
18845       result = (arg1)->GetActionName(arg2);
18846     } catch (std::out_of_range& e) {
18847       {
18848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18849       };
18850     } catch (std::exception& e) {
18851       {
18852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18853       };
18854     } catch (...) {
18855       {
18856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18857       };
18858     }
18859   }
18860   jresult = SWIG_csharp_string_callback((&result)->c_str());
18861   return jresult;
18862 }
18863
18864
18865 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
18866   unsigned long jresult ;
18867   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18868   size_t result;
18869
18870   arg1 = (Dali::TypeInfo *)jarg1;
18871   {
18872     try {
18873       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
18874     } catch (std::out_of_range& e) {
18875       {
18876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18877       };
18878     } catch (std::exception& e) {
18879       {
18880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18881       };
18882     } catch (...) {
18883       {
18884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18885       };
18886     }
18887   }
18888   jresult = (unsigned long)result;
18889   return jresult;
18890 }
18891
18892
18893 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
18894   char * jresult ;
18895   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18896   size_t arg2 ;
18897   std::string result;
18898
18899   arg1 = (Dali::TypeInfo *)jarg1;
18900   arg2 = (size_t)jarg2;
18901   {
18902     try {
18903       result = (arg1)->GetSignalName(arg2);
18904     } catch (std::out_of_range& e) {
18905       {
18906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18907       };
18908     } catch (std::exception& e) {
18909       {
18910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18911       };
18912     } catch (...) {
18913       {
18914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18915       };
18916     }
18917   }
18918   jresult = SWIG_csharp_string_callback((&result)->c_str());
18919   return jresult;
18920 }
18921
18922
18923 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
18924   unsigned long jresult ;
18925   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18926   size_t result;
18927
18928   arg1 = (Dali::TypeInfo *)jarg1;
18929   {
18930     try {
18931       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
18932     } catch (std::out_of_range& e) {
18933       {
18934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18935       };
18936     } catch (std::exception& e) {
18937       {
18938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18939       };
18940     } catch (...) {
18941       {
18942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18943       };
18944     }
18945   }
18946   jresult = (unsigned long)result;
18947   return jresult;
18948 }
18949
18950
18951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
18952   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18953   Dali::Property::IndexContainer *arg2 = 0 ;
18954
18955   arg1 = (Dali::TypeInfo *)jarg1;
18956   arg2 = (Dali::Property::IndexContainer *)jarg2;
18957   if (!arg2) {
18958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18959     return ;
18960   }
18961   {
18962     try {
18963       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
18964     } catch (std::out_of_range& e) {
18965       {
18966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18967       };
18968     } catch (std::exception& e) {
18969       {
18970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18971       };
18972     } catch (...) {
18973       {
18974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18975       };
18976     }
18977   }
18978 }
18979
18980
18981 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
18982   char * jresult ;
18983   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18984   Dali::Property::Index arg2 ;
18985   std::string *result = 0 ;
18986
18987   arg1 = (Dali::TypeInfo *)jarg1;
18988   arg2 = (Dali::Property::Index)jarg2;
18989   {
18990     try {
18991       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
18992     } catch (std::out_of_range& e) {
18993       {
18994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18995       };
18996     } catch (std::exception& e) {
18997       {
18998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18999       };
19000     } catch (...) {
19001       {
19002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19003       };
19004     }
19005   }
19006   jresult = SWIG_csharp_string_callback(result->c_str());
19007   return jresult;
19008 }
19009
19010
19011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
19012   void * jresult ;
19013   Dali::TypeRegistry result;
19014
19015   {
19016     try {
19017       result = Dali::TypeRegistry::Get();
19018     } catch (std::out_of_range& e) {
19019       {
19020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19021       };
19022     } catch (std::exception& e) {
19023       {
19024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19025       };
19026     } catch (...) {
19027       {
19028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19029       };
19030     }
19031   }
19032   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
19033   return jresult;
19034 }
19035
19036
19037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
19038   void * jresult ;
19039   Dali::TypeRegistry *result = 0 ;
19040
19041   {
19042     try {
19043       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
19044     } catch (std::out_of_range& e) {
19045       {
19046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19047       };
19048     } catch (std::exception& e) {
19049       {
19050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19051       };
19052     } catch (...) {
19053       {
19054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19055       };
19056     }
19057   }
19058   jresult = (void *)result;
19059   return jresult;
19060 }
19061
19062
19063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
19064   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19065
19066   arg1 = (Dali::TypeRegistry *)jarg1;
19067   {
19068     try {
19069       delete arg1;
19070     } catch (std::out_of_range& e) {
19071       {
19072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19073       };
19074     } catch (std::exception& e) {
19075       {
19076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19077       };
19078     } catch (...) {
19079       {
19080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19081       };
19082     }
19083   }
19084 }
19085
19086
19087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
19088   void * jresult ;
19089   Dali::TypeRegistry *arg1 = 0 ;
19090   Dali::TypeRegistry *result = 0 ;
19091
19092   arg1 = (Dali::TypeRegistry *)jarg1;
19093   if (!arg1) {
19094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19095     return 0;
19096   }
19097   {
19098     try {
19099       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
19100     } catch (std::out_of_range& e) {
19101       {
19102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19103       };
19104     } catch (std::exception& e) {
19105       {
19106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19107       };
19108     } catch (...) {
19109       {
19110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19111       };
19112     }
19113   }
19114   jresult = (void *)result;
19115   return jresult;
19116 }
19117
19118
19119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
19120   void * jresult ;
19121   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19122   Dali::TypeRegistry *arg2 = 0 ;
19123   Dali::TypeRegistry *result = 0 ;
19124
19125   arg1 = (Dali::TypeRegistry *)jarg1;
19126   arg2 = (Dali::TypeRegistry *)jarg2;
19127   if (!arg2) {
19128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19129     return 0;
19130   }
19131   {
19132     try {
19133       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
19134     } catch (std::out_of_range& e) {
19135       {
19136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19137       };
19138     } catch (std::exception& e) {
19139       {
19140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19141       };
19142     } catch (...) {
19143       {
19144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19145       };
19146     }
19147   }
19148   jresult = (void *)result;
19149   return jresult;
19150 }
19151
19152
19153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
19154   void * jresult ;
19155   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19156   std::string *arg2 = 0 ;
19157   Dali::TypeInfo result;
19158
19159   arg1 = (Dali::TypeRegistry *)jarg1;
19160   if (!jarg2) {
19161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19162     return 0;
19163   }
19164   std::string arg2_str(jarg2);
19165   arg2 = &arg2_str;
19166   {
19167     try {
19168       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
19169     } catch (std::out_of_range& e) {
19170       {
19171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19172       };
19173     } catch (std::exception& e) {
19174       {
19175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19176       };
19177     } catch (...) {
19178       {
19179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19180       };
19181     }
19182   }
19183   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19184
19185   //argout typemap for const std::string&
19186
19187   return jresult;
19188 }
19189
19190
19191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
19192   void * jresult ;
19193   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19194   std::type_info *arg2 = 0 ;
19195   Dali::TypeInfo result;
19196
19197   arg1 = (Dali::TypeRegistry *)jarg1;
19198   arg2 = (std::type_info *)jarg2;
19199   if (!arg2) {
19200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19201     return 0;
19202   }
19203   {
19204     try {
19205       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
19206     } catch (std::out_of_range& e) {
19207       {
19208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19209       };
19210     } catch (std::exception& e) {
19211       {
19212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19213       };
19214     } catch (...) {
19215       {
19216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19217       };
19218     }
19219   }
19220   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19221   return jresult;
19222 }
19223
19224
19225 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
19226   unsigned long jresult ;
19227   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19228   size_t result;
19229
19230   arg1 = (Dali::TypeRegistry *)jarg1;
19231   {
19232     try {
19233       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
19234     } catch (std::out_of_range& e) {
19235       {
19236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19237       };
19238     } catch (std::exception& e) {
19239       {
19240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19241       };
19242     } catch (...) {
19243       {
19244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19245       };
19246     }
19247   }
19248   jresult = (unsigned long)result;
19249   return jresult;
19250 }
19251
19252
19253 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
19254   char * jresult ;
19255   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19256   size_t arg2 ;
19257   std::string result;
19258
19259   arg1 = (Dali::TypeRegistry *)jarg1;
19260   arg2 = (size_t)jarg2;
19261   {
19262     try {
19263       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
19264     } catch (std::out_of_range& e) {
19265       {
19266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19267       };
19268     } catch (std::exception& e) {
19269       {
19270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19271       };
19272     } catch (...) {
19273       {
19274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19275       };
19276     }
19277   }
19278   jresult = SWIG_csharp_string_callback((&result)->c_str());
19279   return jresult;
19280 }
19281
19282
19283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_2(void * jarg1) {
19284   void * jresult ;
19285   Dali::Internal::TypeRegistry *arg1 = (Dali::Internal::TypeRegistry *) 0 ;
19286   Dali::TypeRegistry *result = 0 ;
19287
19288   arg1 = (Dali::Internal::TypeRegistry *)jarg1;
19289   {
19290     try {
19291       result = (Dali::TypeRegistry *)new Dali::TypeRegistry(arg1);
19292     } catch (std::out_of_range& e) {
19293       {
19294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19295       };
19296     } catch (std::exception& e) {
19297       {
19298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19299       };
19300     } catch (...) {
19301       {
19302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19303       };
19304     }
19305   }
19306   jresult = (void *)result;
19307   return jresult;
19308 }
19309
19310
19311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
19312   void * jresult ;
19313   std::type_info *arg1 = 0 ;
19314   std::type_info *arg2 = 0 ;
19315   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19316   Dali::TypeRegistration *result = 0 ;
19317
19318   arg1 = (std::type_info *)jarg1;
19319   if (!arg1) {
19320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19321     return 0;
19322   }
19323   arg2 = (std::type_info *)jarg2;
19324   if (!arg2) {
19325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19326     return 0;
19327   }
19328   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19329   {
19330     try {
19331       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
19332     } catch (std::out_of_range& e) {
19333       {
19334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19335       };
19336     } catch (std::exception& e) {
19337       {
19338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19339       };
19340     } catch (...) {
19341       {
19342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19343       };
19344     }
19345   }
19346   jresult = (void *)result;
19347   return jresult;
19348 }
19349
19350
19351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
19352   void * jresult ;
19353   std::type_info *arg1 = 0 ;
19354   std::type_info *arg2 = 0 ;
19355   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19356   bool arg4 ;
19357   Dali::TypeRegistration *result = 0 ;
19358
19359   arg1 = (std::type_info *)jarg1;
19360   if (!arg1) {
19361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19362     return 0;
19363   }
19364   arg2 = (std::type_info *)jarg2;
19365   if (!arg2) {
19366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19367     return 0;
19368   }
19369   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19370   arg4 = jarg4 ? true : false;
19371   {
19372     try {
19373       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
19374     } catch (std::out_of_range& e) {
19375       {
19376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19377       };
19378     } catch (std::exception& e) {
19379       {
19380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19381       };
19382     } catch (...) {
19383       {
19384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19385       };
19386     }
19387   }
19388   jresult = (void *)result;
19389   return jresult;
19390 }
19391
19392
19393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
19394   void * jresult ;
19395   std::string *arg1 = 0 ;
19396   std::type_info *arg2 = 0 ;
19397   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19398   Dali::TypeRegistration *result = 0 ;
19399
19400   if (!jarg1) {
19401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19402     return 0;
19403   }
19404   std::string arg1_str(jarg1);
19405   arg1 = &arg1_str;
19406   arg2 = (std::type_info *)jarg2;
19407   if (!arg2) {
19408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19409     return 0;
19410   }
19411   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19412   {
19413     try {
19414       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
19415     } catch (std::out_of_range& e) {
19416       {
19417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19418       };
19419     } catch (std::exception& e) {
19420       {
19421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19422       };
19423     } catch (...) {
19424       {
19425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19426       };
19427     }
19428   }
19429   jresult = (void *)result;
19430
19431   //argout typemap for const std::string&
19432
19433   return jresult;
19434 }
19435
19436
19437 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
19438   char * jresult ;
19439   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19440   std::string result;
19441
19442   arg1 = (Dali::TypeRegistration *)jarg1;
19443   {
19444     try {
19445       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
19446     } catch (std::out_of_range& e) {
19447       {
19448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19449       };
19450     } catch (std::exception& e) {
19451       {
19452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19453       };
19454     } catch (...) {
19455       {
19456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19457       };
19458     }
19459   }
19460   jresult = SWIG_csharp_string_callback((&result)->c_str());
19461   return jresult;
19462 }
19463
19464
19465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
19466   std::string *arg1 = 0 ;
19467   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
19468
19469   if (!jarg1) {
19470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19471     return ;
19472   }
19473   std::string arg1_str(jarg1);
19474   arg1 = &arg1_str;
19475   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
19476   {
19477     try {
19478       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
19479     } catch (std::out_of_range& e) {
19480       {
19481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19482       };
19483     } catch (std::exception& e) {
19484       {
19485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19486       };
19487     } catch (...) {
19488       {
19489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19490       };
19491     }
19492   }
19493
19494   //argout typemap for const std::string&
19495
19496 }
19497
19498
19499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19500   std::string *arg1 = 0 ;
19501   std::string *arg2 = 0 ;
19502   int arg3 ;
19503   Dali::Property::Type arg4 ;
19504   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
19505   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
19506
19507   if (!jarg1) {
19508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19509     return ;
19510   }
19511   std::string arg1_str(jarg1);
19512   arg1 = &arg1_str;
19513   if (!jarg2) {
19514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19515     return ;
19516   }
19517   std::string arg2_str(jarg2);
19518   arg2 = &arg2_str;
19519   arg3 = (int)jarg3;
19520   arg4 = (Dali::Property::Type)jarg4;
19521   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
19522   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
19523   {
19524     try {
19525       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19526     } catch (std::out_of_range& e) {
19527       {
19528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19529       };
19530     } catch (std::exception& e) {
19531       {
19532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19533       };
19534     } catch (...) {
19535       {
19536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19537       };
19538     }
19539   }
19540
19541   //argout typemap for const std::string&
19542
19543
19544   //argout typemap for const std::string&
19545
19546 }
19547
19548
19549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
19550   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19551
19552   arg1 = (Dali::TypeRegistration *)jarg1;
19553   {
19554     try {
19555       delete arg1;
19556     } catch (std::out_of_range& e) {
19557       {
19558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19559       };
19560     } catch (std::exception& e) {
19561       {
19562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19563       };
19564     } catch (...) {
19565       {
19566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19567       };
19568     }
19569   }
19570 }
19571
19572
19573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
19574   void * jresult ;
19575   Dali::TypeRegistration *arg1 = 0 ;
19576   std::string *arg2 = 0 ;
19577   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
19578   Dali::SignalConnectorType *result = 0 ;
19579
19580   arg1 = (Dali::TypeRegistration *)jarg1;
19581   if (!arg1) {
19582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19583     return 0;
19584   }
19585   if (!jarg2) {
19586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19587     return 0;
19588   }
19589   std::string arg2_str(jarg2);
19590   arg2 = &arg2_str;
19591   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
19592   {
19593     try {
19594       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
19595     } catch (std::out_of_range& e) {
19596       {
19597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19598       };
19599     } catch (std::exception& e) {
19600       {
19601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19602       };
19603     } catch (...) {
19604       {
19605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19606       };
19607     }
19608   }
19609   jresult = (void *)result;
19610
19611   //argout typemap for const std::string&
19612
19613   return jresult;
19614 }
19615
19616
19617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
19618   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
19619
19620   arg1 = (Dali::SignalConnectorType *)jarg1;
19621   {
19622     try {
19623       delete arg1;
19624     } catch (std::out_of_range& e) {
19625       {
19626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19627       };
19628     } catch (std::exception& e) {
19629       {
19630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19631       };
19632     } catch (...) {
19633       {
19634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19635       };
19636     }
19637   }
19638 }
19639
19640
19641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
19642   void * jresult ;
19643   Dali::TypeRegistration *arg1 = 0 ;
19644   std::string *arg2 = 0 ;
19645   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
19646   Dali::TypeAction *result = 0 ;
19647
19648   arg1 = (Dali::TypeRegistration *)jarg1;
19649   if (!arg1) {
19650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19651     return 0;
19652   }
19653   if (!jarg2) {
19654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19655     return 0;
19656   }
19657   std::string arg2_str(jarg2);
19658   arg2 = &arg2_str;
19659   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
19660   {
19661     try {
19662       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
19663     } catch (std::out_of_range& e) {
19664       {
19665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19666       };
19667     } catch (std::exception& e) {
19668       {
19669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19670       };
19671     } catch (...) {
19672       {
19673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19674       };
19675     }
19676   }
19677   jresult = (void *)result;
19678
19679   //argout typemap for const std::string&
19680
19681   return jresult;
19682 }
19683
19684
19685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
19686   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
19687
19688   arg1 = (Dali::TypeAction *)jarg1;
19689   {
19690     try {
19691       delete arg1;
19692     } catch (std::out_of_range& e) {
19693       {
19694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19695       };
19696     } catch (std::exception& e) {
19697       {
19698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19699       };
19700     } catch (...) {
19701       {
19702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19703       };
19704     }
19705   }
19706 }
19707
19708
19709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19710   void * jresult ;
19711   Dali::TypeRegistration *arg1 = 0 ;
19712   std::string *arg2 = 0 ;
19713   Dali::Property::Index arg3 ;
19714   Dali::Property::Type arg4 ;
19715   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
19716   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
19717   Dali::PropertyRegistration *result = 0 ;
19718
19719   arg1 = (Dali::TypeRegistration *)jarg1;
19720   if (!arg1) {
19721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19722     return 0;
19723   }
19724   if (!jarg2) {
19725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19726     return 0;
19727   }
19728   std::string arg2_str(jarg2);
19729   arg2 = &arg2_str;
19730   arg3 = (Dali::Property::Index)jarg3;
19731   arg4 = (Dali::Property::Type)jarg4;
19732   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
19733   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
19734   {
19735     try {
19736       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19737     } catch (std::out_of_range& e) {
19738       {
19739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19740       };
19741     } catch (std::exception& e) {
19742       {
19743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19744       };
19745     } catch (...) {
19746       {
19747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19748       };
19749     }
19750   }
19751   jresult = (void *)result;
19752
19753   //argout typemap for const std::string&
19754
19755   return jresult;
19756 }
19757
19758
19759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
19760   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
19761
19762   arg1 = (Dali::PropertyRegistration *)jarg1;
19763   {
19764     try {
19765       delete arg1;
19766     } catch (std::out_of_range& e) {
19767       {
19768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19769       };
19770     } catch (std::exception& e) {
19771       {
19772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19773       };
19774     } catch (...) {
19775       {
19776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19777       };
19778     }
19779   }
19780 }
19781
19782
19783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19784   void * jresult ;
19785   Dali::TypeRegistration *arg1 = 0 ;
19786   std::string *arg2 = 0 ;
19787   Dali::Property::Index arg3 ;
19788   Dali::Property::Type arg4 ;
19789   Dali::AnimatablePropertyRegistration *result = 0 ;
19790
19791   arg1 = (Dali::TypeRegistration *)jarg1;
19792   if (!arg1) {
19793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19794     return 0;
19795   }
19796   if (!jarg2) {
19797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19798     return 0;
19799   }
19800   std::string arg2_str(jarg2);
19801   arg2 = &arg2_str;
19802   arg3 = (Dali::Property::Index)jarg3;
19803   arg4 = (Dali::Property::Type)jarg4;
19804   {
19805     try {
19806       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19807     } catch (std::out_of_range& e) {
19808       {
19809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19810       };
19811     } catch (std::exception& e) {
19812       {
19813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19814       };
19815     } catch (...) {
19816       {
19817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19818       };
19819     }
19820   }
19821   jresult = (void *)result;
19822
19823   //argout typemap for const std::string&
19824
19825   return jresult;
19826 }
19827
19828
19829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
19830   void * jresult ;
19831   Dali::TypeRegistration *arg1 = 0 ;
19832   std::string *arg2 = 0 ;
19833   Dali::Property::Index arg3 ;
19834   Dali::Property::Value *arg4 = 0 ;
19835   Dali::AnimatablePropertyRegistration *result = 0 ;
19836
19837   arg1 = (Dali::TypeRegistration *)jarg1;
19838   if (!arg1) {
19839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19840     return 0;
19841   }
19842   if (!jarg2) {
19843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19844     return 0;
19845   }
19846   std::string arg2_str(jarg2);
19847   arg2 = &arg2_str;
19848   arg3 = (Dali::Property::Index)jarg3;
19849   arg4 = (Dali::Property::Value *)jarg4;
19850   if (!arg4) {
19851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
19852     return 0;
19853   }
19854   {
19855     try {
19856       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
19857     } catch (std::out_of_range& e) {
19858       {
19859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19860       };
19861     } catch (std::exception& e) {
19862       {
19863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19864       };
19865     } catch (...) {
19866       {
19867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19868       };
19869     }
19870   }
19871   jresult = (void *)result;
19872
19873   //argout typemap for const std::string&
19874
19875   return jresult;
19876 }
19877
19878
19879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
19880   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
19881
19882   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
19883   {
19884     try {
19885       delete arg1;
19886     } catch (std::out_of_range& e) {
19887       {
19888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19889       };
19890     } catch (std::exception& e) {
19891       {
19892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19893       };
19894     } catch (...) {
19895       {
19896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19897       };
19898     }
19899   }
19900 }
19901
19902
19903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
19904   void * jresult ;
19905   Dali::TypeRegistration *arg1 = 0 ;
19906   std::string *arg2 = 0 ;
19907   Dali::Property::Index arg3 ;
19908   Dali::Property::Index arg4 ;
19909   unsigned int arg5 ;
19910   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
19911
19912   arg1 = (Dali::TypeRegistration *)jarg1;
19913   if (!arg1) {
19914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19915     return 0;
19916   }
19917   if (!jarg2) {
19918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19919     return 0;
19920   }
19921   std::string arg2_str(jarg2);
19922   arg2 = &arg2_str;
19923   arg3 = (Dali::Property::Index)jarg3;
19924   arg4 = (Dali::Property::Index)jarg4;
19925   arg5 = (unsigned int)jarg5;
19926   {
19927     try {
19928       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
19929     } catch (std::out_of_range& e) {
19930       {
19931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19932       };
19933     } catch (std::exception& e) {
19934       {
19935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19936       };
19937     } catch (...) {
19938       {
19939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19940       };
19941     }
19942   }
19943   jresult = (void *)result;
19944
19945   //argout typemap for const std::string&
19946
19947   return jresult;
19948 }
19949
19950
19951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
19952   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
19953
19954   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
19955   {
19956     try {
19957       delete arg1;
19958     } catch (std::out_of_range& e) {
19959       {
19960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19961       };
19962     } catch (std::exception& e) {
19963       {
19964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19965       };
19966     } catch (...) {
19967       {
19968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19969       };
19970     }
19971   }
19972 }
19973
19974
19975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19976   void * jresult ;
19977   Dali::TypeRegistration *arg1 = 0 ;
19978   std::string *arg2 = 0 ;
19979   Dali::Property::Index arg3 ;
19980   Dali::Property::Type arg4 ;
19981   Dali::ChildPropertyRegistration *result = 0 ;
19982
19983   arg1 = (Dali::TypeRegistration *)jarg1;
19984   if (!arg1) {
19985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19986     return 0;
19987   }
19988   if (!jarg2) {
19989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19990     return 0;
19991   }
19992   std::string arg2_str(jarg2);
19993   arg2 = &arg2_str;
19994   arg3 = (Dali::Property::Index)jarg3;
19995   arg4 = (Dali::Property::Type)jarg4;
19996   {
19997     try {
19998       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19999     } catch (std::out_of_range& e) {
20000       {
20001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20002       };
20003     } catch (std::exception& e) {
20004       {
20005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20006       };
20007     } catch (...) {
20008       {
20009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20010       };
20011     }
20012   }
20013   jresult = (void *)result;
20014
20015   //argout typemap for const std::string&
20016
20017   return jresult;
20018 }
20019
20020
20021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
20022   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
20023
20024   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
20025   {
20026     try {
20027       delete arg1;
20028     } catch (std::out_of_range& e) {
20029       {
20030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20031       };
20032     } catch (std::exception& e) {
20033       {
20034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20035       };
20036     } catch (...) {
20037       {
20038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20039       };
20040     }
20041   }
20042 }
20043
20044
20045 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
20046   unsigned int jresult ;
20047   std::string *arg1 = 0 ;
20048   std::type_info *arg2 = 0 ;
20049   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
20050   bool result;
20051
20052   if (!jarg1) {
20053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20054     return 0;
20055   }
20056   std::string arg1_str(jarg1);
20057   arg1 = &arg1_str;
20058   arg2 = (std::type_info *)jarg2;
20059   if (!arg2) {
20060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
20061     return 0;
20062   }
20063   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
20064   {
20065     try {
20066       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
20067     } catch (std::out_of_range& e) {
20068       {
20069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20070       };
20071     } catch (std::exception& e) {
20072       {
20073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20074       };
20075     } catch (...) {
20076       {
20077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20078       };
20079     }
20080   }
20081   jresult = result;
20082
20083   //argout typemap for const std::string&
20084
20085   return jresult;
20086 }
20087
20088
20089 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
20090   unsigned int jresult ;
20091   std::string *arg1 = 0 ;
20092   std::string *arg2 = 0 ;
20093   Dali::Property::Index arg3 ;
20094   Dali::Property::Type arg4 ;
20095   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
20096   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
20097   bool result;
20098
20099   if (!jarg1) {
20100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20101     return 0;
20102   }
20103   std::string arg1_str(jarg1);
20104   arg1 = &arg1_str;
20105   if (!jarg2) {
20106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20107     return 0;
20108   }
20109   std::string arg2_str(jarg2);
20110   arg2 = &arg2_str;
20111   arg3 = (Dali::Property::Index)jarg3;
20112   arg4 = (Dali::Property::Type)jarg4;
20113   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
20114   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
20115   {
20116     try {
20117       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
20118     } catch (std::out_of_range& e) {
20119       {
20120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20121       };
20122     } catch (std::exception& e) {
20123       {
20124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20125       };
20126     } catch (...) {
20127       {
20128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20129       };
20130     }
20131   }
20132   jresult = result;
20133
20134   //argout typemap for const std::string&
20135
20136
20137   //argout typemap for const std::string&
20138
20139   return jresult;
20140 }
20141
20142
20143 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
20144   float jresult ;
20145   float result;
20146
20147   result = (float)(float)Dali::ParentOrigin::TOP;
20148   jresult = result;
20149   return jresult;
20150 }
20151
20152
20153 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
20154   float jresult ;
20155   float result;
20156
20157   result = (float)(float)Dali::ParentOrigin::BOTTOM;
20158   jresult = result;
20159   return jresult;
20160 }
20161
20162
20163 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
20164   float jresult ;
20165   float result;
20166
20167   result = (float)(float)Dali::ParentOrigin::LEFT;
20168   jresult = result;
20169   return jresult;
20170 }
20171
20172
20173 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
20174   float jresult ;
20175   float result;
20176
20177   result = (float)(float)Dali::ParentOrigin::RIGHT;
20178   jresult = result;
20179   return jresult;
20180 }
20181
20182
20183 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
20184   float jresult ;
20185   float result;
20186
20187   result = (float)(float)Dali::ParentOrigin::MIDDLE;
20188   jresult = result;
20189   return jresult;
20190 }
20191
20192
20193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
20194   void * jresult ;
20195   Dali::Vector3 *result = 0 ;
20196
20197   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
20198   jresult = (void *)result;
20199   return jresult;
20200 }
20201
20202
20203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
20204   void * jresult ;
20205   Dali::Vector3 *result = 0 ;
20206
20207   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
20208   jresult = (void *)result;
20209   return jresult;
20210 }
20211
20212
20213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
20214   void * jresult ;
20215   Dali::Vector3 *result = 0 ;
20216
20217   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
20218   jresult = (void *)result;
20219   return jresult;
20220 }
20221
20222
20223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
20224   void * jresult ;
20225   Dali::Vector3 *result = 0 ;
20226
20227   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
20228   jresult = (void *)result;
20229   return jresult;
20230 }
20231
20232
20233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
20234   void * jresult ;
20235   Dali::Vector3 *result = 0 ;
20236
20237   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
20238   jresult = (void *)result;
20239   return jresult;
20240 }
20241
20242
20243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
20244   void * jresult ;
20245   Dali::Vector3 *result = 0 ;
20246
20247   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
20248   jresult = (void *)result;
20249   return jresult;
20250 }
20251
20252
20253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
20254   void * jresult ;
20255   Dali::Vector3 *result = 0 ;
20256
20257   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
20258   jresult = (void *)result;
20259   return jresult;
20260 }
20261
20262
20263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
20264   void * jresult ;
20265   Dali::Vector3 *result = 0 ;
20266
20267   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
20268   jresult = (void *)result;
20269   return jresult;
20270 }
20271
20272
20273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
20274   void * jresult ;
20275   Dali::Vector3 *result = 0 ;
20276
20277   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
20278   jresult = (void *)result;
20279   return jresult;
20280 }
20281
20282
20283 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
20284   float jresult ;
20285   float result;
20286
20287   result = (float)(float)Dali::AnchorPoint::TOP;
20288   jresult = result;
20289   return jresult;
20290 }
20291
20292
20293 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
20294   float jresult ;
20295   float result;
20296
20297   result = (float)(float)Dali::AnchorPoint::BOTTOM;
20298   jresult = result;
20299   return jresult;
20300 }
20301
20302
20303 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
20304   float jresult ;
20305   float result;
20306
20307   result = (float)(float)Dali::AnchorPoint::LEFT;
20308   jresult = result;
20309   return jresult;
20310 }
20311
20312
20313 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
20314   float jresult ;
20315   float result;
20316
20317   result = (float)(float)Dali::AnchorPoint::RIGHT;
20318   jresult = result;
20319   return jresult;
20320 }
20321
20322
20323 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
20324   float jresult ;
20325   float result;
20326
20327   result = (float)(float)Dali::AnchorPoint::MIDDLE;
20328   jresult = result;
20329   return jresult;
20330 }
20331
20332
20333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
20334   void * jresult ;
20335   Dali::Vector3 *result = 0 ;
20336
20337   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
20338   jresult = (void *)result;
20339   return jresult;
20340 }
20341
20342
20343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
20344   void * jresult ;
20345   Dali::Vector3 *result = 0 ;
20346
20347   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
20348   jresult = (void *)result;
20349   return jresult;
20350 }
20351
20352
20353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
20354   void * jresult ;
20355   Dali::Vector3 *result = 0 ;
20356
20357   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
20358   jresult = (void *)result;
20359   return jresult;
20360 }
20361
20362
20363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
20364   void * jresult ;
20365   Dali::Vector3 *result = 0 ;
20366
20367   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
20368   jresult = (void *)result;
20369   return jresult;
20370 }
20371
20372
20373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
20374   void * jresult ;
20375   Dali::Vector3 *result = 0 ;
20376
20377   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
20378   jresult = (void *)result;
20379   return jresult;
20380 }
20381
20382
20383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
20384   void * jresult ;
20385   Dali::Vector3 *result = 0 ;
20386
20387   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
20388   jresult = (void *)result;
20389   return jresult;
20390 }
20391
20392
20393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
20394   void * jresult ;
20395   Dali::Vector3 *result = 0 ;
20396
20397   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
20398   jresult = (void *)result;
20399   return jresult;
20400 }
20401
20402
20403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
20404   void * jresult ;
20405   Dali::Vector3 *result = 0 ;
20406
20407   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
20408   jresult = (void *)result;
20409   return jresult;
20410 }
20411
20412
20413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
20414   void * jresult ;
20415   Dali::Vector3 *result = 0 ;
20416
20417   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
20418   jresult = (void *)result;
20419   return jresult;
20420 }
20421
20422
20423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
20424   void * jresult ;
20425   Dali::Vector4 *result = 0 ;
20426
20427   result = (Dali::Vector4 *)&Dali::Color::BLACK;
20428   jresult = (void *)result;
20429   return jresult;
20430 }
20431
20432
20433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
20434   void * jresult ;
20435   Dali::Vector4 *result = 0 ;
20436
20437   result = (Dali::Vector4 *)&Dali::Color::WHITE;
20438   jresult = (void *)result;
20439   return jresult;
20440 }
20441
20442
20443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
20444   void * jresult ;
20445   Dali::Vector4 *result = 0 ;
20446
20447   result = (Dali::Vector4 *)&Dali::Color::RED;
20448   jresult = (void *)result;
20449   return jresult;
20450 }
20451
20452
20453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
20454   void * jresult ;
20455   Dali::Vector4 *result = 0 ;
20456
20457   result = (Dali::Vector4 *)&Dali::Color::GREEN;
20458   jresult = (void *)result;
20459   return jresult;
20460 }
20461
20462
20463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
20464   void * jresult ;
20465   Dali::Vector4 *result = 0 ;
20466
20467   result = (Dali::Vector4 *)&Dali::Color::BLUE;
20468   jresult = (void *)result;
20469   return jresult;
20470 }
20471
20472
20473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
20474   void * jresult ;
20475   Dali::Vector4 *result = 0 ;
20476
20477   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
20478   jresult = (void *)result;
20479   return jresult;
20480 }
20481
20482
20483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
20484   void * jresult ;
20485   Dali::Vector4 *result = 0 ;
20486
20487   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
20488   jresult = (void *)result;
20489   return jresult;
20490 }
20491
20492
20493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
20494   void * jresult ;
20495   Dali::Vector4 *result = 0 ;
20496
20497   result = (Dali::Vector4 *)&Dali::Color::CYAN;
20498   jresult = (void *)result;
20499   return jresult;
20500 }
20501
20502
20503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
20504   void * jresult ;
20505   Dali::Vector4 *result = 0 ;
20506
20507   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
20508   jresult = (void *)result;
20509   return jresult;
20510 }
20511
20512
20513 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
20514   float jresult ;
20515   float result;
20516
20517   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
20518   jresult = result;
20519   return jresult;
20520 }
20521
20522
20523 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
20524   float jresult ;
20525   float result;
20526
20527   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
20528   jresult = result;
20529   return jresult;
20530 }
20531
20532
20533 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
20534   float jresult ;
20535   float result;
20536
20537   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
20538   jresult = result;
20539   return jresult;
20540 }
20541
20542
20543 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
20544   float jresult ;
20545   float result;
20546
20547   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
20548   jresult = result;
20549   return jresult;
20550 }
20551
20552
20553 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
20554   float jresult ;
20555   float result;
20556
20557   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
20558   jresult = result;
20559   return jresult;
20560 }
20561
20562
20563 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
20564   float jresult ;
20565   float result;
20566
20567   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
20568   jresult = result;
20569   return jresult;
20570 }
20571
20572
20573 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
20574   float jresult ;
20575   float result;
20576
20577   result = (float)(float)Dali::Math::PI;
20578   jresult = result;
20579   return jresult;
20580 }
20581
20582
20583 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
20584   float jresult ;
20585   float result;
20586
20587   result = (float)(float)Dali::Math::PI_2;
20588   jresult = result;
20589   return jresult;
20590 }
20591
20592
20593 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
20594   float jresult ;
20595   float result;
20596
20597   result = (float)(float)Dali::Math::PI_4;
20598   jresult = result;
20599   return jresult;
20600 }
20601
20602
20603 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
20604   float jresult ;
20605   float result;
20606
20607   result = (float)(float)Dali::Math::PI_OVER_180;
20608   jresult = result;
20609   return jresult;
20610 }
20611
20612
20613 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
20614   float jresult ;
20615   float result;
20616
20617   result = (float)(float)Dali::Math::ONE80_OVER_PI;
20618   jresult = result;
20619   return jresult;
20620 }
20621
20622
20623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
20624   int jresult ;
20625   Dali::ResizePolicy::Type result;
20626
20627   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
20628   jresult = (int)result;
20629   return jresult;
20630 }
20631
20632
20633 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
20634   unsigned long jresult ;
20635   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20636   Dali::VectorBase::SizeType result;
20637
20638   arg1 = (Dali::VectorBase *)jarg1;
20639   {
20640     try {
20641       result = ((Dali::VectorBase const *)arg1)->Count();
20642     } catch (std::out_of_range& e) {
20643       {
20644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20645       };
20646     } catch (std::exception& e) {
20647       {
20648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20649       };
20650     } catch (...) {
20651       {
20652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20653       };
20654     }
20655   }
20656   jresult = (unsigned long)result;
20657   return jresult;
20658 }
20659
20660
20661 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
20662   unsigned long jresult ;
20663   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20664   Dali::VectorBase::SizeType result;
20665
20666   arg1 = (Dali::VectorBase *)jarg1;
20667   {
20668     try {
20669       result = ((Dali::VectorBase const *)arg1)->Size();
20670     } catch (std::out_of_range& e) {
20671       {
20672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20673       };
20674     } catch (std::exception& e) {
20675       {
20676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20677       };
20678     } catch (...) {
20679       {
20680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20681       };
20682     }
20683   }
20684   jresult = (unsigned long)result;
20685   return jresult;
20686 }
20687
20688
20689 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
20690   unsigned int jresult ;
20691   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20692   bool result;
20693
20694   arg1 = (Dali::VectorBase *)jarg1;
20695   {
20696     try {
20697       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
20698     } catch (std::out_of_range& e) {
20699       {
20700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20701       };
20702     } catch (std::exception& e) {
20703       {
20704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20705       };
20706     } catch (...) {
20707       {
20708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20709       };
20710     }
20711   }
20712   jresult = result;
20713   return jresult;
20714 }
20715
20716
20717 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
20718   unsigned long jresult ;
20719   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20720   Dali::VectorBase::SizeType result;
20721
20722   arg1 = (Dali::VectorBase *)jarg1;
20723   {
20724     try {
20725       result = ((Dali::VectorBase const *)arg1)->Capacity();
20726     } catch (std::out_of_range& e) {
20727       {
20728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20729       };
20730     } catch (std::exception& e) {
20731       {
20732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20733       };
20734     } catch (...) {
20735       {
20736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20737       };
20738     }
20739   }
20740   jresult = (unsigned long)result;
20741   return jresult;
20742 }
20743
20744
20745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
20746   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20747
20748   arg1 = (Dali::VectorBase *)jarg1;
20749   {
20750     try {
20751       (arg1)->Release();
20752     } catch (std::out_of_range& e) {
20753       {
20754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20755       };
20756     } catch (std::exception& e) {
20757       {
20758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20759       };
20760     } catch (...) {
20761       {
20762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20763       };
20764     }
20765   }
20766 }
20767
20768
20769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
20770   void * jresult ;
20771   Dali::Image *result = 0 ;
20772
20773   {
20774     try {
20775       result = (Dali::Image *)new Dali::Image();
20776     } catch (std::out_of_range& e) {
20777       {
20778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20779       };
20780     } catch (std::exception& e) {
20781       {
20782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20783       };
20784     } catch (...) {
20785       {
20786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20787       };
20788     }
20789   }
20790   jresult = (void *)result;
20791   return jresult;
20792 }
20793
20794
20795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
20796   Dali::Image *arg1 = (Dali::Image *) 0 ;
20797
20798   arg1 = (Dali::Image *)jarg1;
20799   {
20800     try {
20801       delete arg1;
20802     } catch (std::out_of_range& e) {
20803       {
20804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20805       };
20806     } catch (std::exception& e) {
20807       {
20808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20809       };
20810     } catch (...) {
20811       {
20812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20813       };
20814     }
20815   }
20816 }
20817
20818
20819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
20820   void * jresult ;
20821   Dali::Image *arg1 = 0 ;
20822   Dali::Image *result = 0 ;
20823
20824   arg1 = (Dali::Image *)jarg1;
20825   if (!arg1) {
20826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20827     return 0;
20828   }
20829   {
20830     try {
20831       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
20832     } catch (std::out_of_range& e) {
20833       {
20834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20835       };
20836     } catch (std::exception& e) {
20837       {
20838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20839       };
20840     } catch (...) {
20841       {
20842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20843       };
20844     }
20845   }
20846   jresult = (void *)result;
20847   return jresult;
20848 }
20849
20850
20851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
20852   void * jresult ;
20853   Dali::Image *arg1 = (Dali::Image *) 0 ;
20854   Dali::Image *arg2 = 0 ;
20855   Dali::Image *result = 0 ;
20856
20857   arg1 = (Dali::Image *)jarg1;
20858   arg2 = (Dali::Image *)jarg2;
20859   if (!arg2) {
20860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20861     return 0;
20862   }
20863   {
20864     try {
20865       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
20866     } catch (std::out_of_range& e) {
20867       {
20868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20869       };
20870     } catch (std::exception& e) {
20871       {
20872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20873       };
20874     } catch (...) {
20875       {
20876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20877       };
20878     }
20879   }
20880   jresult = (void *)result;
20881   return jresult;
20882 }
20883
20884
20885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
20886   void * jresult ;
20887   Dali::BaseHandle arg1 ;
20888   Dali::BaseHandle *argp1 ;
20889   Dali::Image result;
20890
20891   argp1 = (Dali::BaseHandle *)jarg1;
20892   if (!argp1) {
20893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20894     return 0;
20895   }
20896   arg1 = *argp1;
20897   {
20898     try {
20899       result = Dali::Image::DownCast(arg1);
20900     } catch (std::out_of_range& e) {
20901       {
20902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20903       };
20904     } catch (std::exception& e) {
20905       {
20906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20907       };
20908     } catch (...) {
20909       {
20910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20911       };
20912     }
20913   }
20914   jresult = new Dali::Image((const Dali::Image &)result);
20915   return jresult;
20916 }
20917
20918
20919 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
20920   unsigned int jresult ;
20921   Dali::Image *arg1 = (Dali::Image *) 0 ;
20922   unsigned int result;
20923
20924   arg1 = (Dali::Image *)jarg1;
20925   {
20926     try {
20927       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
20928     } catch (std::out_of_range& e) {
20929       {
20930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20931       };
20932     } catch (std::exception& e) {
20933       {
20934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20935       };
20936     } catch (...) {
20937       {
20938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20939       };
20940     }
20941   }
20942   jresult = result;
20943   return jresult;
20944 }
20945
20946
20947 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
20948   unsigned int jresult ;
20949   Dali::Image *arg1 = (Dali::Image *) 0 ;
20950   unsigned int result;
20951
20952   arg1 = (Dali::Image *)jarg1;
20953   {
20954     try {
20955       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
20956     } catch (std::out_of_range& e) {
20957       {
20958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20959       };
20960     } catch (std::exception& e) {
20961       {
20962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20963       };
20964     } catch (...) {
20965       {
20966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20967       };
20968     }
20969   }
20970   jresult = result;
20971   return jresult;
20972 }
20973
20974
20975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
20976   void * jresult ;
20977   Dali::Image *arg1 = (Dali::Image *) 0 ;
20978   Dali::Image::ImageSignalType *result = 0 ;
20979
20980   arg1 = (Dali::Image *)jarg1;
20981   {
20982     try {
20983       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
20984     } catch (std::out_of_range& e) {
20985       {
20986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20987       };
20988     } catch (std::exception& e) {
20989       {
20990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20991       };
20992     } catch (...) {
20993       {
20994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20995       };
20996     }
20997   }
20998   jresult = (void *)result;
20999   return jresult;
21000 }
21001
21002
21003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
21004   int jresult ;
21005   Dali::Pixel::Format result;
21006
21007   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
21008   jresult = (int)result;
21009   return jresult;
21010 }
21011
21012
21013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
21014   int jresult ;
21015   Dali::Pixel::Format result;
21016
21017   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
21018   jresult = (int)result;
21019   return jresult;
21020 }
21021
21022
21023 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
21024   unsigned int jresult ;
21025   Dali::Pixel::Format arg1 ;
21026   bool result;
21027
21028   arg1 = (Dali::Pixel::Format)jarg1;
21029   {
21030     try {
21031       result = (bool)Dali::Pixel::HasAlpha(arg1);
21032     } catch (std::out_of_range& e) {
21033       {
21034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21035       };
21036     } catch (std::exception& e) {
21037       {
21038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21039       };
21040     } catch (...) {
21041       {
21042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21043       };
21044     }
21045   }
21046   jresult = result;
21047   return jresult;
21048 }
21049
21050
21051 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
21052   unsigned int jresult ;
21053   Dali::Pixel::Format arg1 ;
21054   unsigned int result;
21055
21056   arg1 = (Dali::Pixel::Format)jarg1;
21057   {
21058     try {
21059       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
21060     } catch (std::out_of_range& e) {
21061       {
21062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21063       };
21064     } catch (std::exception& e) {
21065       {
21066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21067       };
21068     } catch (...) {
21069       {
21070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21071       };
21072     }
21073   }
21074   jresult = result;
21075   return jresult;
21076 }
21077
21078
21079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
21080   Dali::Pixel::Format arg1 ;
21081   int *arg2 = 0 ;
21082   int *arg3 = 0 ;
21083
21084   arg1 = (Dali::Pixel::Format)jarg1;
21085   arg2 = (int *)jarg2;
21086   if (!arg2) {
21087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21088     return ;
21089   }
21090   arg3 = (int *)jarg3;
21091   if (!arg3) {
21092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21093     return ;
21094   }
21095   {
21096     try {
21097       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
21098     } catch (std::out_of_range& e) {
21099       {
21100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21101       };
21102     } catch (std::exception& e) {
21103       {
21104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21105       };
21106     } catch (...) {
21107       {
21108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21109       };
21110     }
21111   }
21112 }
21113
21114
21115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
21116   void * jresult ;
21117   unsigned char *arg1 = (unsigned char *) 0 ;
21118   unsigned int arg2 ;
21119   unsigned int arg3 ;
21120   unsigned int arg4 ;
21121   Dali::Pixel::Format arg5 ;
21122   Dali::PixelData::ReleaseFunction arg6 ;
21123   Dali::PixelData result;
21124
21125   arg1 = jarg1;
21126   arg2 = (unsigned int)jarg2;
21127   arg3 = (unsigned int)jarg3;
21128   arg4 = (unsigned int)jarg4;
21129   arg5 = (Dali::Pixel::Format)jarg5;
21130   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
21131   {
21132     try {
21133       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
21134     } catch (std::out_of_range& e) {
21135       {
21136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21137       };
21138     } catch (std::exception& e) {
21139       {
21140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21141       };
21142     } catch (...) {
21143       {
21144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21145       };
21146     }
21147   }
21148   jresult = new Dali::PixelData((const Dali::PixelData &)result);
21149
21150
21151   return jresult;
21152 }
21153
21154
21155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
21156   void * jresult ;
21157   Dali::PixelData *result = 0 ;
21158
21159   {
21160     try {
21161       result = (Dali::PixelData *)new Dali::PixelData();
21162     } catch (std::out_of_range& e) {
21163       {
21164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21165       };
21166     } catch (std::exception& e) {
21167       {
21168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21169       };
21170     } catch (...) {
21171       {
21172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21173       };
21174     }
21175   }
21176   jresult = (void *)result;
21177   return jresult;
21178 }
21179
21180
21181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
21182   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21183
21184   arg1 = (Dali::PixelData *)jarg1;
21185   {
21186     try {
21187       delete arg1;
21188     } catch (std::out_of_range& e) {
21189       {
21190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21191       };
21192     } catch (std::exception& e) {
21193       {
21194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21195       };
21196     } catch (...) {
21197       {
21198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21199       };
21200     }
21201   }
21202 }
21203
21204
21205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
21206   void * jresult ;
21207   Dali::PixelData *arg1 = 0 ;
21208   Dali::PixelData *result = 0 ;
21209
21210   arg1 = (Dali::PixelData *)jarg1;
21211   if (!arg1) {
21212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21213     return 0;
21214   }
21215   {
21216     try {
21217       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
21218     } catch (std::out_of_range& e) {
21219       {
21220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21221       };
21222     } catch (std::exception& e) {
21223       {
21224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21225       };
21226     } catch (...) {
21227       {
21228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21229       };
21230     }
21231   }
21232   jresult = (void *)result;
21233   return jresult;
21234 }
21235
21236
21237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
21238   void * jresult ;
21239   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21240   Dali::PixelData *arg2 = 0 ;
21241   Dali::PixelData *result = 0 ;
21242
21243   arg1 = (Dali::PixelData *)jarg1;
21244   arg2 = (Dali::PixelData *)jarg2;
21245   if (!arg2) {
21246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21247     return 0;
21248   }
21249   {
21250     try {
21251       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
21252     } catch (std::out_of_range& e) {
21253       {
21254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21255       };
21256     } catch (std::exception& e) {
21257       {
21258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21259       };
21260     } catch (...) {
21261       {
21262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21263       };
21264     }
21265   }
21266   jresult = (void *)result;
21267   return jresult;
21268 }
21269
21270
21271 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
21272   unsigned int jresult ;
21273   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21274   unsigned int result;
21275
21276   arg1 = (Dali::PixelData *)jarg1;
21277   {
21278     try {
21279       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
21280     } catch (std::out_of_range& e) {
21281       {
21282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21283       };
21284     } catch (std::exception& e) {
21285       {
21286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21287       };
21288     } catch (...) {
21289       {
21290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21291       };
21292     }
21293   }
21294   jresult = result;
21295   return jresult;
21296 }
21297
21298
21299 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
21300   unsigned int jresult ;
21301   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21302   unsigned int result;
21303
21304   arg1 = (Dali::PixelData *)jarg1;
21305   {
21306     try {
21307       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
21308     } catch (std::out_of_range& e) {
21309       {
21310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21311       };
21312     } catch (std::exception& e) {
21313       {
21314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21315       };
21316     } catch (...) {
21317       {
21318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21319       };
21320     }
21321   }
21322   jresult = result;
21323   return jresult;
21324 }
21325
21326
21327 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
21328   int jresult ;
21329   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21330   Dali::Pixel::Format result;
21331
21332   arg1 = (Dali::PixelData *)jarg1;
21333   {
21334     try {
21335       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
21336     } catch (std::out_of_range& e) {
21337       {
21338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21339       };
21340     } catch (std::exception& e) {
21341       {
21342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21343       };
21344     } catch (...) {
21345       {
21346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21347       };
21348     }
21349   }
21350   jresult = (int)result;
21351   return jresult;
21352 }
21353
21354
21355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
21356   unsigned int jresult ;
21357   unsigned int result;
21358
21359   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
21360   jresult = result;
21361   return jresult;
21362 }
21363
21364
21365 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
21366   unsigned int jresult ;
21367   unsigned int result;
21368
21369   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
21370   jresult = result;
21371   return jresult;
21372 }
21373
21374
21375 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
21376   unsigned int jresult ;
21377   unsigned int result;
21378
21379   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
21380   jresult = result;
21381   return jresult;
21382 }
21383
21384
21385 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
21386   unsigned int jresult ;
21387   unsigned int result;
21388
21389   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
21390   jresult = result;
21391   return jresult;
21392 }
21393
21394
21395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
21396   unsigned int jresult ;
21397   unsigned int result;
21398
21399   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
21400   jresult = result;
21401   return jresult;
21402 }
21403
21404
21405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
21406   unsigned int jresult ;
21407   unsigned int result;
21408
21409   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
21410   jresult = result;
21411   return jresult;
21412 }
21413
21414
21415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
21416   void * jresult ;
21417   Dali::TextureType::Type arg1 ;
21418   Dali::Pixel::Format arg2 ;
21419   unsigned int arg3 ;
21420   unsigned int arg4 ;
21421   Dali::Texture result;
21422
21423   arg1 = (Dali::TextureType::Type)jarg1;
21424   arg2 = (Dali::Pixel::Format)jarg2;
21425   arg3 = (unsigned int)jarg3;
21426   arg4 = (unsigned int)jarg4;
21427   {
21428     try {
21429       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
21430     } catch (std::out_of_range& e) {
21431       {
21432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21433       };
21434     } catch (std::exception& e) {
21435       {
21436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21437       };
21438     } catch (...) {
21439       {
21440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21441       };
21442     }
21443   }
21444   jresult = new Dali::Texture((const Dali::Texture &)result);
21445   return jresult;
21446 }
21447
21448
21449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
21450   void * jresult ;
21451   NativeImageInterface *arg1 = 0 ;
21452   Dali::Texture result;
21453
21454   arg1 = (NativeImageInterface *)jarg1;
21455   if (!arg1) {
21456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
21457     return 0;
21458   }
21459   {
21460     try {
21461       result = Dali::Texture::New(*arg1);
21462     } catch (std::out_of_range& e) {
21463       {
21464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21465       };
21466     } catch (std::exception& e) {
21467       {
21468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21469       };
21470     } catch (...) {
21471       {
21472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21473       };
21474     }
21475   }
21476   jresult = new Dali::Texture((const Dali::Texture &)result);
21477   return jresult;
21478 }
21479
21480
21481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
21482   void * jresult ;
21483   Dali::Texture *result = 0 ;
21484
21485   {
21486     try {
21487       result = (Dali::Texture *)new Dali::Texture();
21488     } catch (std::out_of_range& e) {
21489       {
21490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21491       };
21492     } catch (std::exception& e) {
21493       {
21494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21495       };
21496     } catch (...) {
21497       {
21498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21499       };
21500     }
21501   }
21502   jresult = (void *)result;
21503   return jresult;
21504 }
21505
21506
21507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
21508   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21509
21510   arg1 = (Dali::Texture *)jarg1;
21511   {
21512     try {
21513       delete arg1;
21514     } catch (std::out_of_range& e) {
21515       {
21516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21517       };
21518     } catch (std::exception& e) {
21519       {
21520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21521       };
21522     } catch (...) {
21523       {
21524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21525       };
21526     }
21527   }
21528 }
21529
21530
21531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
21532   void * jresult ;
21533   Dali::Texture *arg1 = 0 ;
21534   Dali::Texture *result = 0 ;
21535
21536   arg1 = (Dali::Texture *)jarg1;
21537   if (!arg1) {
21538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21539     return 0;
21540   }
21541   {
21542     try {
21543       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
21544     } catch (std::out_of_range& e) {
21545       {
21546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21547       };
21548     } catch (std::exception& e) {
21549       {
21550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21551       };
21552     } catch (...) {
21553       {
21554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21555       };
21556     }
21557   }
21558   jresult = (void *)result;
21559   return jresult;
21560 }
21561
21562
21563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
21564   void * jresult ;
21565   Dali::BaseHandle arg1 ;
21566   Dali::BaseHandle *argp1 ;
21567   Dali::Texture result;
21568
21569   argp1 = (Dali::BaseHandle *)jarg1;
21570   if (!argp1) {
21571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21572     return 0;
21573   }
21574   arg1 = *argp1;
21575   {
21576     try {
21577       result = Dali::Texture::DownCast(arg1);
21578     } catch (std::out_of_range& e) {
21579       {
21580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21581       };
21582     } catch (std::exception& e) {
21583       {
21584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21585       };
21586     } catch (...) {
21587       {
21588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21589       };
21590     }
21591   }
21592   jresult = new Dali::Texture((const Dali::Texture &)result);
21593   return jresult;
21594 }
21595
21596
21597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
21598   void * jresult ;
21599   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21600   Dali::Texture *arg2 = 0 ;
21601   Dali::Texture *result = 0 ;
21602
21603   arg1 = (Dali::Texture *)jarg1;
21604   arg2 = (Dali::Texture *)jarg2;
21605   if (!arg2) {
21606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21607     return 0;
21608   }
21609   {
21610     try {
21611       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
21612     } catch (std::out_of_range& e) {
21613       {
21614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21615       };
21616     } catch (std::exception& e) {
21617       {
21618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21619       };
21620     } catch (...) {
21621       {
21622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21623       };
21624     }
21625   }
21626   jresult = (void *)result;
21627   return jresult;
21628 }
21629
21630
21631 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
21632   unsigned int jresult ;
21633   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21634   Dali::PixelData arg2 ;
21635   Dali::PixelData *argp2 ;
21636   bool result;
21637
21638   arg1 = (Dali::Texture *)jarg1;
21639   argp2 = (Dali::PixelData *)jarg2;
21640   if (!argp2) {
21641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21642     return 0;
21643   }
21644   arg2 = *argp2;
21645   {
21646     try {
21647       result = (bool)(arg1)->Upload(arg2);
21648     } catch (std::out_of_range& e) {
21649       {
21650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21651       };
21652     } catch (std::exception& e) {
21653       {
21654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21655       };
21656     } catch (...) {
21657       {
21658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21659       };
21660     }
21661   }
21662   jresult = result;
21663   return jresult;
21664 }
21665
21666
21667 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4, unsigned int jarg5, unsigned int jarg6, unsigned int jarg7, unsigned int jarg8) {
21668   unsigned int jresult ;
21669   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21670   Dali::PixelData arg2 ;
21671   unsigned int arg3 ;
21672   unsigned int arg4 ;
21673   unsigned int arg5 ;
21674   unsigned int arg6 ;
21675   unsigned int arg7 ;
21676   unsigned int arg8 ;
21677   Dali::PixelData *argp2 ;
21678   bool result;
21679
21680   arg1 = (Dali::Texture *)jarg1;
21681   argp2 = (Dali::PixelData *)jarg2;
21682   if (!argp2) {
21683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21684     return 0;
21685   }
21686   arg2 = *argp2;
21687   arg3 = (unsigned int)jarg3;
21688   arg4 = (unsigned int)jarg4;
21689   arg5 = (unsigned int)jarg5;
21690   arg6 = (unsigned int)jarg6;
21691   arg7 = (unsigned int)jarg7;
21692   arg8 = (unsigned int)jarg8;
21693   {
21694     try {
21695       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
21696     } catch (std::out_of_range& e) {
21697       {
21698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21699       };
21700     } catch (std::exception& e) {
21701       {
21702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21703       };
21704     } catch (...) {
21705       {
21706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21707       };
21708     }
21709   }
21710   jresult = result;
21711   return jresult;
21712 }
21713
21714
21715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
21716   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21717
21718   arg1 = (Dali::Texture *)jarg1;
21719   {
21720     try {
21721       (arg1)->GenerateMipmaps();
21722     } catch (std::out_of_range& e) {
21723       {
21724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21725       };
21726     } catch (std::exception& e) {
21727       {
21728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21729       };
21730     } catch (...) {
21731       {
21732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21733       };
21734     }
21735   }
21736 }
21737
21738
21739 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
21740   unsigned int jresult ;
21741   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21742   unsigned int result;
21743
21744   arg1 = (Dali::Texture *)jarg1;
21745   {
21746     try {
21747       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
21748     } catch (std::out_of_range& e) {
21749       {
21750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21751       };
21752     } catch (std::exception& e) {
21753       {
21754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21755       };
21756     } catch (...) {
21757       {
21758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21759       };
21760     }
21761   }
21762   jresult = result;
21763   return jresult;
21764 }
21765
21766
21767 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
21768   unsigned int jresult ;
21769   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21770   unsigned int result;
21771
21772   arg1 = (Dali::Texture *)jarg1;
21773   {
21774     try {
21775       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
21776     } catch (std::out_of_range& e) {
21777       {
21778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21779       };
21780     } catch (std::exception& e) {
21781       {
21782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21783       };
21784     } catch (...) {
21785       {
21786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21787       };
21788     }
21789   }
21790   jresult = result;
21791   return jresult;
21792 }
21793
21794
21795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_2(void * jarg1) {
21796   void * jresult ;
21797   Dali::Internal::Texture *arg1 = (Dali::Internal::Texture *) 0 ;
21798   Dali::Texture *result = 0 ;
21799
21800   arg1 = (Dali::Internal::Texture *)jarg1;
21801   {
21802     try {
21803       result = (Dali::Texture *)new Dali::Texture(arg1);
21804     } catch (std::out_of_range& e) {
21805       {
21806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21807       };
21808     } catch (std::exception& e) {
21809       {
21810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21811       };
21812     } catch (...) {
21813       {
21814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21815       };
21816     }
21817   }
21818   jresult = (void *)result;
21819   return jresult;
21820 }
21821
21822
21823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
21824   void * jresult ;
21825   Dali::Sampler result;
21826
21827   {
21828     try {
21829       result = Dali::Sampler::New();
21830     } catch (std::out_of_range& e) {
21831       {
21832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21833       };
21834     } catch (std::exception& e) {
21835       {
21836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21837       };
21838     } catch (...) {
21839       {
21840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21841       };
21842     }
21843   }
21844   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21845   return jresult;
21846 }
21847
21848
21849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
21850   void * jresult ;
21851   Dali::Sampler *result = 0 ;
21852
21853   {
21854     try {
21855       result = (Dali::Sampler *)new Dali::Sampler();
21856     } catch (std::out_of_range& e) {
21857       {
21858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21859       };
21860     } catch (std::exception& e) {
21861       {
21862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21863       };
21864     } catch (...) {
21865       {
21866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21867       };
21868     }
21869   }
21870   jresult = (void *)result;
21871   return jresult;
21872 }
21873
21874
21875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
21876   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21877
21878   arg1 = (Dali::Sampler *)jarg1;
21879   {
21880     try {
21881       delete arg1;
21882     } catch (std::out_of_range& e) {
21883       {
21884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21885       };
21886     } catch (std::exception& e) {
21887       {
21888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21889       };
21890     } catch (...) {
21891       {
21892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21893       };
21894     }
21895   }
21896 }
21897
21898
21899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
21900   void * jresult ;
21901   Dali::Sampler *arg1 = 0 ;
21902   Dali::Sampler *result = 0 ;
21903
21904   arg1 = (Dali::Sampler *)jarg1;
21905   if (!arg1) {
21906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21907     return 0;
21908   }
21909   {
21910     try {
21911       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
21912     } catch (std::out_of_range& e) {
21913       {
21914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21915       };
21916     } catch (std::exception& e) {
21917       {
21918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21919       };
21920     } catch (...) {
21921       {
21922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21923       };
21924     }
21925   }
21926   jresult = (void *)result;
21927   return jresult;
21928 }
21929
21930
21931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
21932   void * jresult ;
21933   Dali::BaseHandle arg1 ;
21934   Dali::BaseHandle *argp1 ;
21935   Dali::Sampler result;
21936
21937   argp1 = (Dali::BaseHandle *)jarg1;
21938   if (!argp1) {
21939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21940     return 0;
21941   }
21942   arg1 = *argp1;
21943   {
21944     try {
21945       result = Dali::Sampler::DownCast(arg1);
21946     } catch (std::out_of_range& e) {
21947       {
21948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21949       };
21950     } catch (std::exception& e) {
21951       {
21952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21953       };
21954     } catch (...) {
21955       {
21956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21957       };
21958     }
21959   }
21960   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21961   return jresult;
21962 }
21963
21964
21965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
21966   void * jresult ;
21967   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21968   Dali::Sampler *arg2 = 0 ;
21969   Dali::Sampler *result = 0 ;
21970
21971   arg1 = (Dali::Sampler *)jarg1;
21972   arg2 = (Dali::Sampler *)jarg2;
21973   if (!arg2) {
21974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21975     return 0;
21976   }
21977   {
21978     try {
21979       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
21980     } catch (std::out_of_range& e) {
21981       {
21982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21983       };
21984     } catch (std::exception& e) {
21985       {
21986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21987       };
21988     } catch (...) {
21989       {
21990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21991       };
21992     }
21993   }
21994   jresult = (void *)result;
21995   return jresult;
21996 }
21997
21998
21999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
22000   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22001   Dali::FilterMode::Type arg2 ;
22002   Dali::FilterMode::Type arg3 ;
22003
22004   arg1 = (Dali::Sampler *)jarg1;
22005   arg2 = (Dali::FilterMode::Type)jarg2;
22006   arg3 = (Dali::FilterMode::Type)jarg3;
22007   {
22008     try {
22009       (arg1)->SetFilterMode(arg2,arg3);
22010     } catch (std::out_of_range& e) {
22011       {
22012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22013       };
22014     } catch (std::exception& e) {
22015       {
22016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22017       };
22018     } catch (...) {
22019       {
22020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22021       };
22022     }
22023   }
22024 }
22025
22026
22027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
22028   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22029   Dali::WrapMode::Type arg2 ;
22030   Dali::WrapMode::Type arg3 ;
22031
22032   arg1 = (Dali::Sampler *)jarg1;
22033   arg2 = (Dali::WrapMode::Type)jarg2;
22034   arg3 = (Dali::WrapMode::Type)jarg3;
22035   {
22036     try {
22037       (arg1)->SetWrapMode(arg2,arg3);
22038     } catch (std::out_of_range& e) {
22039       {
22040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22041       };
22042     } catch (std::exception& e) {
22043       {
22044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22045       };
22046     } catch (...) {
22047       {
22048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22049       };
22050     }
22051   }
22052 }
22053
22054
22055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
22056   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22057   Dali::WrapMode::Type arg2 ;
22058   Dali::WrapMode::Type arg3 ;
22059   Dali::WrapMode::Type arg4 ;
22060
22061   arg1 = (Dali::Sampler *)jarg1;
22062   arg2 = (Dali::WrapMode::Type)jarg2;
22063   arg3 = (Dali::WrapMode::Type)jarg3;
22064   arg4 = (Dali::WrapMode::Type)jarg4;
22065   {
22066     try {
22067       (arg1)->SetWrapMode(arg2,arg3,arg4);
22068     } catch (std::out_of_range& e) {
22069       {
22070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22071       };
22072     } catch (std::exception& e) {
22073       {
22074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22075       };
22076     } catch (...) {
22077       {
22078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22079       };
22080     }
22081   }
22082 }
22083
22084
22085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
22086   void * jresult ;
22087   Dali::TextureSet result;
22088
22089   {
22090     try {
22091       result = Dali::TextureSet::New();
22092     } catch (std::out_of_range& e) {
22093       {
22094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22095       };
22096     } catch (std::exception& e) {
22097       {
22098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22099       };
22100     } catch (...) {
22101       {
22102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22103       };
22104     }
22105   }
22106   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22107   return jresult;
22108 }
22109
22110
22111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
22112   void * jresult ;
22113   Dali::TextureSet *result = 0 ;
22114
22115   {
22116     try {
22117       result = (Dali::TextureSet *)new Dali::TextureSet();
22118     } catch (std::out_of_range& e) {
22119       {
22120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22121       };
22122     } catch (std::exception& e) {
22123       {
22124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22125       };
22126     } catch (...) {
22127       {
22128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22129       };
22130     }
22131   }
22132   jresult = (void *)result;
22133   return jresult;
22134 }
22135
22136
22137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
22138   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22139
22140   arg1 = (Dali::TextureSet *)jarg1;
22141   {
22142     try {
22143       delete arg1;
22144     } catch (std::out_of_range& e) {
22145       {
22146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22147       };
22148     } catch (std::exception& e) {
22149       {
22150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22151       };
22152     } catch (...) {
22153       {
22154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22155       };
22156     }
22157   }
22158 }
22159
22160
22161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
22162   void * jresult ;
22163   Dali::TextureSet *arg1 = 0 ;
22164   Dali::TextureSet *result = 0 ;
22165
22166   arg1 = (Dali::TextureSet *)jarg1;
22167   if (!arg1) {
22168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22169     return 0;
22170   }
22171   {
22172     try {
22173       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
22174     } catch (std::out_of_range& e) {
22175       {
22176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22177       };
22178     } catch (std::exception& e) {
22179       {
22180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22181       };
22182     } catch (...) {
22183       {
22184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22185       };
22186     }
22187   }
22188   jresult = (void *)result;
22189   return jresult;
22190 }
22191
22192
22193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
22194   void * jresult ;
22195   Dali::BaseHandle arg1 ;
22196   Dali::BaseHandle *argp1 ;
22197   Dali::TextureSet result;
22198
22199   argp1 = (Dali::BaseHandle *)jarg1;
22200   if (!argp1) {
22201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22202     return 0;
22203   }
22204   arg1 = *argp1;
22205   {
22206     try {
22207       result = Dali::TextureSet::DownCast(arg1);
22208     } catch (std::out_of_range& e) {
22209       {
22210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22211       };
22212     } catch (std::exception& e) {
22213       {
22214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22215       };
22216     } catch (...) {
22217       {
22218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22219       };
22220     }
22221   }
22222   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22223   return jresult;
22224 }
22225
22226
22227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
22228   void * jresult ;
22229   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22230   Dali::TextureSet *arg2 = 0 ;
22231   Dali::TextureSet *result = 0 ;
22232
22233   arg1 = (Dali::TextureSet *)jarg1;
22234   arg2 = (Dali::TextureSet *)jarg2;
22235   if (!arg2) {
22236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22237     return 0;
22238   }
22239   {
22240     try {
22241       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
22242     } catch (std::out_of_range& e) {
22243       {
22244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22245       };
22246     } catch (std::exception& e) {
22247       {
22248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22249       };
22250     } catch (...) {
22251       {
22252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22253       };
22254     }
22255   }
22256   jresult = (void *)result;
22257   return jresult;
22258 }
22259
22260
22261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
22262   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22263   size_t arg2 ;
22264   Dali::Texture arg3 ;
22265   Dali::Texture *argp3 ;
22266
22267   arg1 = (Dali::TextureSet *)jarg1;
22268   arg2 = (size_t)jarg2;
22269   argp3 = (Dali::Texture *)jarg3;
22270   if (!argp3) {
22271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
22272     return ;
22273   }
22274   arg3 = *argp3;
22275   {
22276     try {
22277       (arg1)->SetTexture(arg2,arg3);
22278     } catch (std::out_of_range& e) {
22279       {
22280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22281       };
22282     } catch (std::exception& e) {
22283       {
22284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22285       };
22286     } catch (...) {
22287       {
22288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22289       };
22290     }
22291   }
22292 }
22293
22294
22295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
22296   void * jresult ;
22297   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22298   size_t arg2 ;
22299   Dali::Texture result;
22300
22301   arg1 = (Dali::TextureSet *)jarg1;
22302   arg2 = (size_t)jarg2;
22303   {
22304     try {
22305       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
22306     } catch (std::out_of_range& e) {
22307       {
22308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22309       };
22310     } catch (std::exception& e) {
22311       {
22312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22313       };
22314     } catch (...) {
22315       {
22316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22317       };
22318     }
22319   }
22320   jresult = new Dali::Texture((const Dali::Texture &)result);
22321   return jresult;
22322 }
22323
22324
22325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
22326   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22327   size_t arg2 ;
22328   Dali::Sampler arg3 ;
22329   Dali::Sampler *argp3 ;
22330
22331   arg1 = (Dali::TextureSet *)jarg1;
22332   arg2 = (size_t)jarg2;
22333   argp3 = (Dali::Sampler *)jarg3;
22334   if (!argp3) {
22335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
22336     return ;
22337   }
22338   arg3 = *argp3;
22339   {
22340     try {
22341       (arg1)->SetSampler(arg2,arg3);
22342     } catch (std::out_of_range& e) {
22343       {
22344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22345       };
22346     } catch (std::exception& e) {
22347       {
22348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22349       };
22350     } catch (...) {
22351       {
22352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22353       };
22354     }
22355   }
22356 }
22357
22358
22359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
22360   void * jresult ;
22361   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22362   size_t arg2 ;
22363   Dali::Sampler result;
22364
22365   arg1 = (Dali::TextureSet *)jarg1;
22366   arg2 = (size_t)jarg2;
22367   {
22368     try {
22369       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
22370     } catch (std::out_of_range& e) {
22371       {
22372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22373       };
22374     } catch (std::exception& e) {
22375       {
22376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22377       };
22378     } catch (...) {
22379       {
22380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22381       };
22382     }
22383   }
22384   jresult = new Dali::Sampler((const Dali::Sampler &)result);
22385   return jresult;
22386 }
22387
22388
22389 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
22390   unsigned long jresult ;
22391   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22392   size_t result;
22393
22394   arg1 = (Dali::TextureSet *)jarg1;
22395   {
22396     try {
22397       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
22398     } catch (std::out_of_range& e) {
22399       {
22400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22401       };
22402     } catch (std::exception& e) {
22403       {
22404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22405       };
22406     } catch (...) {
22407       {
22408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22409       };
22410     }
22411   }
22412   jresult = (unsigned long)result;
22413   return jresult;
22414 }
22415
22416
22417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
22418   void * jresult ;
22419   Dali::Property::Map *arg1 = 0 ;
22420   Dali::PropertyBuffer result;
22421
22422   arg1 = (Dali::Property::Map *)jarg1;
22423   if (!arg1) {
22424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
22425     return 0;
22426   }
22427   {
22428     try {
22429       result = Dali::PropertyBuffer::New(*arg1);
22430     } catch (std::out_of_range& e) {
22431       {
22432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22433       };
22434     } catch (std::exception& e) {
22435       {
22436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22437       };
22438     } catch (...) {
22439       {
22440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22441       };
22442     }
22443   }
22444   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22445   return jresult;
22446 }
22447
22448
22449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
22450   void * jresult ;
22451   Dali::PropertyBuffer *result = 0 ;
22452
22453   {
22454     try {
22455       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
22456     } catch (std::out_of_range& e) {
22457       {
22458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22459       };
22460     } catch (std::exception& e) {
22461       {
22462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22463       };
22464     } catch (...) {
22465       {
22466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22467       };
22468     }
22469   }
22470   jresult = (void *)result;
22471   return jresult;
22472 }
22473
22474
22475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
22476   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22477
22478   arg1 = (Dali::PropertyBuffer *)jarg1;
22479   {
22480     try {
22481       delete arg1;
22482     } catch (std::out_of_range& e) {
22483       {
22484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22485       };
22486     } catch (std::exception& e) {
22487       {
22488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22489       };
22490     } catch (...) {
22491       {
22492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22493       };
22494     }
22495   }
22496 }
22497
22498
22499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
22500   void * jresult ;
22501   Dali::PropertyBuffer *arg1 = 0 ;
22502   Dali::PropertyBuffer *result = 0 ;
22503
22504   arg1 = (Dali::PropertyBuffer *)jarg1;
22505   if (!arg1) {
22506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22507     return 0;
22508   }
22509   {
22510     try {
22511       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
22512     } catch (std::out_of_range& e) {
22513       {
22514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22515       };
22516     } catch (std::exception& e) {
22517       {
22518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22519       };
22520     } catch (...) {
22521       {
22522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22523       };
22524     }
22525   }
22526   jresult = (void *)result;
22527   return jresult;
22528 }
22529
22530
22531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
22532   void * jresult ;
22533   Dali::BaseHandle arg1 ;
22534   Dali::BaseHandle *argp1 ;
22535   Dali::PropertyBuffer result;
22536
22537   argp1 = (Dali::BaseHandle *)jarg1;
22538   if (!argp1) {
22539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22540     return 0;
22541   }
22542   arg1 = *argp1;
22543   {
22544     try {
22545       result = Dali::PropertyBuffer::DownCast(arg1);
22546     } catch (std::out_of_range& e) {
22547       {
22548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22549       };
22550     } catch (std::exception& e) {
22551       {
22552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22553       };
22554     } catch (...) {
22555       {
22556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22557       };
22558     }
22559   }
22560   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22561   return jresult;
22562 }
22563
22564
22565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
22566   void * jresult ;
22567   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22568   Dali::PropertyBuffer *arg2 = 0 ;
22569   Dali::PropertyBuffer *result = 0 ;
22570
22571   arg1 = (Dali::PropertyBuffer *)jarg1;
22572   arg2 = (Dali::PropertyBuffer *)jarg2;
22573   if (!arg2) {
22574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22575     return 0;
22576   }
22577   {
22578     try {
22579       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
22580     } catch (std::out_of_range& e) {
22581       {
22582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22583       };
22584     } catch (std::exception& e) {
22585       {
22586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22587       };
22588     } catch (...) {
22589       {
22590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22591       };
22592     }
22593   }
22594   jresult = (void *)result;
22595   return jresult;
22596 }
22597
22598
22599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
22600   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22601   void *arg2 = (void *) 0 ;
22602   std::size_t arg3 ;
22603
22604   arg1 = (Dali::PropertyBuffer *)jarg1;
22605   arg2 = jarg2;
22606   arg3 = (std::size_t)jarg3;
22607   {
22608     try {
22609       (arg1)->SetData((void const *)arg2,arg3);
22610     } catch (std::out_of_range& e) {
22611       {
22612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22613       };
22614     } catch (std::exception& e) {
22615       {
22616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22617       };
22618     } catch (...) {
22619       {
22620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22621       };
22622     }
22623   }
22624 }
22625
22626
22627 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
22628   unsigned long jresult ;
22629   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22630   std::size_t result;
22631
22632   arg1 = (Dali::PropertyBuffer *)jarg1;
22633   {
22634     try {
22635       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
22636     } catch (std::out_of_range& e) {
22637       {
22638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22639       };
22640     } catch (std::exception& e) {
22641       {
22642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22643       };
22644     } catch (...) {
22645       {
22646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22647       };
22648     }
22649   }
22650   jresult = (unsigned long)result;
22651   return jresult;
22652 }
22653
22654
22655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
22656   void * jresult ;
22657   Dali::Geometry result;
22658
22659   {
22660     try {
22661       result = Dali::Geometry::New();
22662     } catch (std::out_of_range& e) {
22663       {
22664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22665       };
22666     } catch (std::exception& e) {
22667       {
22668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22669       };
22670     } catch (...) {
22671       {
22672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22673       };
22674     }
22675   }
22676   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22677   return jresult;
22678 }
22679
22680
22681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
22682   void * jresult ;
22683   Dali::Geometry *result = 0 ;
22684
22685   {
22686     try {
22687       result = (Dali::Geometry *)new Dali::Geometry();
22688     } catch (std::out_of_range& e) {
22689       {
22690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22691       };
22692     } catch (std::exception& e) {
22693       {
22694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22695       };
22696     } catch (...) {
22697       {
22698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22699       };
22700     }
22701   }
22702   jresult = (void *)result;
22703   return jresult;
22704 }
22705
22706
22707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
22708   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22709
22710   arg1 = (Dali::Geometry *)jarg1;
22711   {
22712     try {
22713       delete arg1;
22714     } catch (std::out_of_range& e) {
22715       {
22716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22717       };
22718     } catch (std::exception& e) {
22719       {
22720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22721       };
22722     } catch (...) {
22723       {
22724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22725       };
22726     }
22727   }
22728 }
22729
22730
22731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
22732   void * jresult ;
22733   Dali::Geometry *arg1 = 0 ;
22734   Dali::Geometry *result = 0 ;
22735
22736   arg1 = (Dali::Geometry *)jarg1;
22737   if (!arg1) {
22738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22739     return 0;
22740   }
22741   {
22742     try {
22743       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
22744     } catch (std::out_of_range& e) {
22745       {
22746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22747       };
22748     } catch (std::exception& e) {
22749       {
22750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22751       };
22752     } catch (...) {
22753       {
22754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22755       };
22756     }
22757   }
22758   jresult = (void *)result;
22759   return jresult;
22760 }
22761
22762
22763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
22764   void * jresult ;
22765   Dali::BaseHandle arg1 ;
22766   Dali::BaseHandle *argp1 ;
22767   Dali::Geometry result;
22768
22769   argp1 = (Dali::BaseHandle *)jarg1;
22770   if (!argp1) {
22771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22772     return 0;
22773   }
22774   arg1 = *argp1;
22775   {
22776     try {
22777       result = Dali::Geometry::DownCast(arg1);
22778     } catch (std::out_of_range& e) {
22779       {
22780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22781       };
22782     } catch (std::exception& e) {
22783       {
22784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22785       };
22786     } catch (...) {
22787       {
22788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22789       };
22790     }
22791   }
22792   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22793   return jresult;
22794 }
22795
22796
22797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
22798   void * jresult ;
22799   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22800   Dali::Geometry *arg2 = 0 ;
22801   Dali::Geometry *result = 0 ;
22802
22803   arg1 = (Dali::Geometry *)jarg1;
22804   arg2 = (Dali::Geometry *)jarg2;
22805   if (!arg2) {
22806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22807     return 0;
22808   }
22809   {
22810     try {
22811       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
22812     } catch (std::out_of_range& e) {
22813       {
22814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22815       };
22816     } catch (std::exception& e) {
22817       {
22818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22819       };
22820     } catch (...) {
22821       {
22822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22823       };
22824     }
22825   }
22826   jresult = (void *)result;
22827   return jresult;
22828 }
22829
22830
22831 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
22832   unsigned long jresult ;
22833   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22834   Dali::PropertyBuffer *arg2 = 0 ;
22835   std::size_t result;
22836
22837   arg1 = (Dali::Geometry *)jarg1;
22838   arg2 = (Dali::PropertyBuffer *)jarg2;
22839   if (!arg2) {
22840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
22841     return 0;
22842   }
22843   {
22844     try {
22845       result = (arg1)->AddVertexBuffer(*arg2);
22846     } catch (std::out_of_range& e) {
22847       {
22848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22849       };
22850     } catch (std::exception& e) {
22851       {
22852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22853       };
22854     } catch (...) {
22855       {
22856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22857       };
22858     }
22859   }
22860   jresult = (unsigned long)result;
22861   return jresult;
22862 }
22863
22864
22865 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
22866   unsigned long jresult ;
22867   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22868   std::size_t result;
22869
22870   arg1 = (Dali::Geometry *)jarg1;
22871   {
22872     try {
22873       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
22874     } catch (std::out_of_range& e) {
22875       {
22876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22877       };
22878     } catch (std::exception& e) {
22879       {
22880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22881       };
22882     } catch (...) {
22883       {
22884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22885       };
22886     }
22887   }
22888   jresult = (unsigned long)result;
22889   return jresult;
22890 }
22891
22892
22893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
22894   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22895   std::size_t arg2 ;
22896
22897   arg1 = (Dali::Geometry *)jarg1;
22898   arg2 = (std::size_t)jarg2;
22899   {
22900     try {
22901       (arg1)->RemoveVertexBuffer(arg2);
22902     } catch (std::out_of_range& e) {
22903       {
22904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22905       };
22906     } catch (std::exception& e) {
22907       {
22908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22909       };
22910     } catch (...) {
22911       {
22912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22913       };
22914     }
22915   }
22916 }
22917
22918
22919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
22920   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22921   unsigned short *arg2 = (unsigned short *) 0 ;
22922   size_t arg3 ;
22923
22924   arg1 = (Dali::Geometry *)jarg1;
22925   arg2 = jarg2;
22926   arg3 = (size_t)jarg3;
22927   {
22928     try {
22929       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
22930     } catch (std::out_of_range& e) {
22931       {
22932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22933       };
22934     } catch (std::exception& e) {
22935       {
22936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22937       };
22938     } catch (...) {
22939       {
22940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22941       };
22942     }
22943   }
22944
22945
22946 }
22947
22948
22949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
22950   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22951   Dali::Geometry::Type arg2 ;
22952
22953   arg1 = (Dali::Geometry *)jarg1;
22954   arg2 = (Dali::Geometry::Type)jarg2;
22955   {
22956     try {
22957       (arg1)->SetType(arg2);
22958     } catch (std::out_of_range& e) {
22959       {
22960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22961       };
22962     } catch (std::exception& e) {
22963       {
22964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22965       };
22966     } catch (...) {
22967       {
22968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22969       };
22970     }
22971   }
22972 }
22973
22974
22975 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
22976   int jresult ;
22977   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22978   Dali::Geometry::Type result;
22979
22980   arg1 = (Dali::Geometry *)jarg1;
22981   {
22982     try {
22983       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
22984     } catch (std::out_of_range& e) {
22985       {
22986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22987       };
22988     } catch (std::exception& e) {
22989       {
22990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22991       };
22992     } catch (...) {
22993       {
22994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22995       };
22996     }
22997   }
22998   jresult = (int)result;
22999   return jresult;
23000 }
23001
23002
23003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
23004   void * jresult ;
23005   Dali::Shader::Hint *result = 0 ;
23006
23007   {
23008     try {
23009       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
23010     } catch (std::out_of_range& e) {
23011       {
23012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23013       };
23014     } catch (std::exception& e) {
23015       {
23016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23017       };
23018     } catch (...) {
23019       {
23020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23021       };
23022     }
23023   }
23024   jresult = (void *)result;
23025   return jresult;
23026 }
23027
23028
23029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
23030   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
23031
23032   arg1 = (Dali::Shader::Hint *)jarg1;
23033   {
23034     try {
23035       delete arg1;
23036     } catch (std::out_of_range& e) {
23037       {
23038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23039       };
23040     } catch (std::exception& e) {
23041       {
23042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23043       };
23044     } catch (...) {
23045       {
23046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23047       };
23048     }
23049   }
23050 }
23051
23052
23053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
23054   int jresult ;
23055   int result;
23056
23057   result = (int)Dali::Shader::Property::PROGRAM;
23058   jresult = (int)result;
23059   return jresult;
23060 }
23061
23062
23063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
23064   void * jresult ;
23065   Dali::Shader::Property *result = 0 ;
23066
23067   {
23068     try {
23069       result = (Dali::Shader::Property *)new Dali::Shader::Property();
23070     } catch (std::out_of_range& e) {
23071       {
23072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23073       };
23074     } catch (std::exception& e) {
23075       {
23076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23077       };
23078     } catch (...) {
23079       {
23080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23081       };
23082     }
23083   }
23084   jresult = (void *)result;
23085   return jresult;
23086 }
23087
23088
23089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
23090   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
23091
23092   arg1 = (Dali::Shader::Property *)jarg1;
23093   {
23094     try {
23095       delete arg1;
23096     } catch (std::out_of_range& e) {
23097       {
23098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23099       };
23100     } catch (std::exception& e) {
23101       {
23102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23103       };
23104     } catch (...) {
23105       {
23106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23107       };
23108     }
23109   }
23110 }
23111
23112
23113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
23114   void * jresult ;
23115   std::string *arg1 = 0 ;
23116   std::string *arg2 = 0 ;
23117   Dali::Shader::Hint::Value arg3 ;
23118   Dali::Shader result;
23119
23120   if (!jarg1) {
23121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23122     return 0;
23123   }
23124   std::string arg1_str(jarg1);
23125   arg1 = &arg1_str;
23126   if (!jarg2) {
23127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23128     return 0;
23129   }
23130   std::string arg2_str(jarg2);
23131   arg2 = &arg2_str;
23132   arg3 = (Dali::Shader::Hint::Value)jarg3;
23133   {
23134     try {
23135       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
23136     } catch (std::out_of_range& e) {
23137       {
23138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23139       };
23140     } catch (std::exception& e) {
23141       {
23142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23143       };
23144     } catch (...) {
23145       {
23146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23147       };
23148     }
23149   }
23150   jresult = new Dali::Shader((const Dali::Shader &)result);
23151
23152   //argout typemap for const std::string&
23153
23154
23155   //argout typemap for const std::string&
23156
23157   return jresult;
23158 }
23159
23160
23161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
23162   void * jresult ;
23163   std::string *arg1 = 0 ;
23164   std::string *arg2 = 0 ;
23165   Dali::Shader result;
23166
23167   if (!jarg1) {
23168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23169     return 0;
23170   }
23171   std::string arg1_str(jarg1);
23172   arg1 = &arg1_str;
23173   if (!jarg2) {
23174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23175     return 0;
23176   }
23177   std::string arg2_str(jarg2);
23178   arg2 = &arg2_str;
23179   {
23180     try {
23181       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
23182     } catch (std::out_of_range& e) {
23183       {
23184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23185       };
23186     } catch (std::exception& e) {
23187       {
23188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23189       };
23190     } catch (...) {
23191       {
23192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23193       };
23194     }
23195   }
23196   jresult = new Dali::Shader((const Dali::Shader &)result);
23197
23198   //argout typemap for const std::string&
23199
23200
23201   //argout typemap for const std::string&
23202
23203   return jresult;
23204 }
23205
23206
23207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
23208   void * jresult ;
23209   Dali::Shader *result = 0 ;
23210
23211   {
23212     try {
23213       result = (Dali::Shader *)new Dali::Shader();
23214     } catch (std::out_of_range& e) {
23215       {
23216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23217       };
23218     } catch (std::exception& e) {
23219       {
23220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23221       };
23222     } catch (...) {
23223       {
23224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23225       };
23226     }
23227   }
23228   jresult = (void *)result;
23229   return jresult;
23230 }
23231
23232
23233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
23234   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23235
23236   arg1 = (Dali::Shader *)jarg1;
23237   {
23238     try {
23239       delete arg1;
23240     } catch (std::out_of_range& e) {
23241       {
23242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23243       };
23244     } catch (std::exception& e) {
23245       {
23246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23247       };
23248     } catch (...) {
23249       {
23250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23251       };
23252     }
23253   }
23254 }
23255
23256
23257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
23258   void * jresult ;
23259   Dali::Shader *arg1 = 0 ;
23260   Dali::Shader *result = 0 ;
23261
23262   arg1 = (Dali::Shader *)jarg1;
23263   if (!arg1) {
23264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23265     return 0;
23266   }
23267   {
23268     try {
23269       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
23270     } catch (std::out_of_range& e) {
23271       {
23272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23273       };
23274     } catch (std::exception& e) {
23275       {
23276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23277       };
23278     } catch (...) {
23279       {
23280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23281       };
23282     }
23283   }
23284   jresult = (void *)result;
23285   return jresult;
23286 }
23287
23288
23289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
23290   void * jresult ;
23291   Dali::BaseHandle arg1 ;
23292   Dali::BaseHandle *argp1 ;
23293   Dali::Shader result;
23294
23295   argp1 = (Dali::BaseHandle *)jarg1;
23296   if (!argp1) {
23297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23298     return 0;
23299   }
23300   arg1 = *argp1;
23301   {
23302     try {
23303       result = Dali::Shader::DownCast(arg1);
23304     } catch (std::out_of_range& e) {
23305       {
23306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23307       };
23308     } catch (std::exception& e) {
23309       {
23310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23311       };
23312     } catch (...) {
23313       {
23314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23315       };
23316     }
23317   }
23318   jresult = new Dali::Shader((const Dali::Shader &)result);
23319   return jresult;
23320 }
23321
23322
23323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
23324   void * jresult ;
23325   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23326   Dali::Shader *arg2 = 0 ;
23327   Dali::Shader *result = 0 ;
23328
23329   arg1 = (Dali::Shader *)jarg1;
23330   arg2 = (Dali::Shader *)jarg2;
23331   if (!arg2) {
23332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23333     return 0;
23334   }
23335   {
23336     try {
23337       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
23338     } catch (std::out_of_range& e) {
23339       {
23340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23341       };
23342     } catch (std::exception& e) {
23343       {
23344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23345       };
23346     } catch (...) {
23347       {
23348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23349       };
23350     }
23351   }
23352   jresult = (void *)result;
23353   return jresult;
23354 }
23355
23356
23357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
23358   int jresult ;
23359   int result;
23360
23361   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
23362   jresult = (int)result;
23363   return jresult;
23364 }
23365
23366
23367 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
23368   int jresult ;
23369   int result;
23370
23371   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
23372   jresult = (int)result;
23373   return jresult;
23374 }
23375
23376
23377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
23378   int jresult ;
23379   int result;
23380
23381   result = (int)Dali::Renderer::Property::BLEND_MODE;
23382   jresult = (int)result;
23383   return jresult;
23384 }
23385
23386
23387 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
23388   int jresult ;
23389   int result;
23390
23391   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
23392   jresult = (int)result;
23393   return jresult;
23394 }
23395
23396
23397 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
23398   int jresult ;
23399   int result;
23400
23401   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
23402   jresult = (int)result;
23403   return jresult;
23404 }
23405
23406
23407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
23408   int jresult ;
23409   int result;
23410
23411   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
23412   jresult = (int)result;
23413   return jresult;
23414 }
23415
23416
23417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
23418   int jresult ;
23419   int result;
23420
23421   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
23422   jresult = (int)result;
23423   return jresult;
23424 }
23425
23426
23427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
23428   int jresult ;
23429   int result;
23430
23431   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
23432   jresult = (int)result;
23433   return jresult;
23434 }
23435
23436
23437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
23438   int jresult ;
23439   int result;
23440
23441   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
23442   jresult = (int)result;
23443   return jresult;
23444 }
23445
23446
23447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
23448   int jresult ;
23449   int result;
23450
23451   result = (int)Dali::Renderer::Property::BLEND_COLOR;
23452   jresult = (int)result;
23453   return jresult;
23454 }
23455
23456
23457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
23458   int jresult ;
23459   int result;
23460
23461   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
23462   jresult = (int)result;
23463   return jresult;
23464 }
23465
23466
23467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
23468   int jresult ;
23469   int result;
23470
23471   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
23472   jresult = (int)result;
23473   return jresult;
23474 }
23475
23476
23477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
23478   int jresult ;
23479   int result;
23480
23481   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
23482   jresult = (int)result;
23483   return jresult;
23484 }
23485
23486
23487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
23488   int jresult ;
23489   int result;
23490
23491   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
23492   jresult = (int)result;
23493   return jresult;
23494 }
23495
23496
23497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
23498   int jresult ;
23499   int result;
23500
23501   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
23502   jresult = (int)result;
23503   return jresult;
23504 }
23505
23506
23507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
23508   int jresult ;
23509   int result;
23510
23511   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
23512   jresult = (int)result;
23513   return jresult;
23514 }
23515
23516
23517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
23518   int jresult ;
23519   int result;
23520
23521   result = (int)Dali::Renderer::Property::RENDER_MODE;
23522   jresult = (int)result;
23523   return jresult;
23524 }
23525
23526
23527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
23528   int jresult ;
23529   int result;
23530
23531   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
23532   jresult = (int)result;
23533   return jresult;
23534 }
23535
23536
23537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
23538   int jresult ;
23539   int result;
23540
23541   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
23542   jresult = (int)result;
23543   return jresult;
23544 }
23545
23546
23547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
23548   int jresult ;
23549   int result;
23550
23551   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
23552   jresult = (int)result;
23553   return jresult;
23554 }
23555
23556
23557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
23558   int jresult ;
23559   int result;
23560
23561   result = (int)Dali::Renderer::Property::STENCIL_MASK;
23562   jresult = (int)result;
23563   return jresult;
23564 }
23565
23566
23567 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
23568   int jresult ;
23569   int result;
23570
23571   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
23572   jresult = (int)result;
23573   return jresult;
23574 }
23575
23576
23577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
23578   int jresult ;
23579   int result;
23580
23581   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
23582   jresult = (int)result;
23583   return jresult;
23584 }
23585
23586
23587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
23588   int jresult ;
23589   int result;
23590
23591   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
23592   jresult = (int)result;
23593   return jresult;
23594 }
23595
23596
23597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
23598   void * jresult ;
23599   Dali::Renderer::Property *result = 0 ;
23600
23601   {
23602     try {
23603       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
23604     } catch (std::out_of_range& e) {
23605       {
23606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23607       };
23608     } catch (std::exception& e) {
23609       {
23610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23611       };
23612     } catch (...) {
23613       {
23614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23615       };
23616     }
23617   }
23618   jresult = (void *)result;
23619   return jresult;
23620 }
23621
23622
23623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
23624   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
23625
23626   arg1 = (Dali::Renderer::Property *)jarg1;
23627   {
23628     try {
23629       delete arg1;
23630     } catch (std::out_of_range& e) {
23631       {
23632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23633       };
23634     } catch (std::exception& e) {
23635       {
23636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23637       };
23638     } catch (...) {
23639       {
23640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23641       };
23642     }
23643   }
23644 }
23645
23646
23647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
23648   void * jresult ;
23649   Dali::Geometry *arg1 = 0 ;
23650   Dali::Shader *arg2 = 0 ;
23651   Dali::Renderer result;
23652
23653   arg1 = (Dali::Geometry *)jarg1;
23654   if (!arg1) {
23655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23656     return 0;
23657   }
23658   arg2 = (Dali::Shader *)jarg2;
23659   if (!arg2) {
23660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23661     return 0;
23662   }
23663   {
23664     try {
23665       result = Dali::Renderer::New(*arg1,*arg2);
23666     } catch (std::out_of_range& e) {
23667       {
23668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23669       };
23670     } catch (std::exception& e) {
23671       {
23672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23673       };
23674     } catch (...) {
23675       {
23676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23677       };
23678     }
23679   }
23680   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23681   return jresult;
23682 }
23683
23684
23685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
23686   void * jresult ;
23687   Dali::Renderer *result = 0 ;
23688
23689   {
23690     try {
23691       result = (Dali::Renderer *)new Dali::Renderer();
23692     } catch (std::out_of_range& e) {
23693       {
23694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23695       };
23696     } catch (std::exception& e) {
23697       {
23698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23699       };
23700     } catch (...) {
23701       {
23702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23703       };
23704     }
23705   }
23706   jresult = (void *)result;
23707   return jresult;
23708 }
23709
23710
23711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
23712   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23713
23714   arg1 = (Dali::Renderer *)jarg1;
23715   {
23716     try {
23717       delete arg1;
23718     } catch (std::out_of_range& e) {
23719       {
23720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23721       };
23722     } catch (std::exception& e) {
23723       {
23724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23725       };
23726     } catch (...) {
23727       {
23728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23729       };
23730     }
23731   }
23732 }
23733
23734
23735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
23736   void * jresult ;
23737   Dali::Renderer *arg1 = 0 ;
23738   Dali::Renderer *result = 0 ;
23739
23740   arg1 = (Dali::Renderer *)jarg1;
23741   if (!arg1) {
23742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23743     return 0;
23744   }
23745   {
23746     try {
23747       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
23748     } catch (std::out_of_range& e) {
23749       {
23750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23751       };
23752     } catch (std::exception& e) {
23753       {
23754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23755       };
23756     } catch (...) {
23757       {
23758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23759       };
23760     }
23761   }
23762   jresult = (void *)result;
23763   return jresult;
23764 }
23765
23766
23767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
23768   void * jresult ;
23769   Dali::BaseHandle arg1 ;
23770   Dali::BaseHandle *argp1 ;
23771   Dali::Renderer result;
23772
23773   argp1 = (Dali::BaseHandle *)jarg1;
23774   if (!argp1) {
23775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23776     return 0;
23777   }
23778   arg1 = *argp1;
23779   {
23780     try {
23781       result = Dali::Renderer::DownCast(arg1);
23782     } catch (std::out_of_range& e) {
23783       {
23784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23785       };
23786     } catch (std::exception& e) {
23787       {
23788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23789       };
23790     } catch (...) {
23791       {
23792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23793       };
23794     }
23795   }
23796   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23797   return jresult;
23798 }
23799
23800
23801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
23802   void * jresult ;
23803   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23804   Dali::Renderer *arg2 = 0 ;
23805   Dali::Renderer *result = 0 ;
23806
23807   arg1 = (Dali::Renderer *)jarg1;
23808   arg2 = (Dali::Renderer *)jarg2;
23809   if (!arg2) {
23810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23811     return 0;
23812   }
23813   {
23814     try {
23815       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
23816     } catch (std::out_of_range& e) {
23817       {
23818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23819       };
23820     } catch (std::exception& e) {
23821       {
23822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23823       };
23824     } catch (...) {
23825       {
23826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23827       };
23828     }
23829   }
23830   jresult = (void *)result;
23831   return jresult;
23832 }
23833
23834
23835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
23836   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23837   Dali::Geometry *arg2 = 0 ;
23838
23839   arg1 = (Dali::Renderer *)jarg1;
23840   arg2 = (Dali::Geometry *)jarg2;
23841   if (!arg2) {
23842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23843     return ;
23844   }
23845   {
23846     try {
23847       (arg1)->SetGeometry(*arg2);
23848     } catch (std::out_of_range& e) {
23849       {
23850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23851       };
23852     } catch (std::exception& e) {
23853       {
23854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23855       };
23856     } catch (...) {
23857       {
23858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23859       };
23860     }
23861   }
23862 }
23863
23864
23865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
23866   void * jresult ;
23867   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23868   Dali::Geometry result;
23869
23870   arg1 = (Dali::Renderer *)jarg1;
23871   {
23872     try {
23873       result = ((Dali::Renderer const *)arg1)->GetGeometry();
23874     } catch (std::out_of_range& e) {
23875       {
23876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23877       };
23878     } catch (std::exception& e) {
23879       {
23880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23881       };
23882     } catch (...) {
23883       {
23884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23885       };
23886     }
23887   }
23888   jresult = new Dali::Geometry((const Dali::Geometry &)result);
23889   return jresult;
23890 }
23891
23892
23893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
23894   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23895   int arg2 ;
23896   int arg3 ;
23897
23898   arg1 = (Dali::Renderer *)jarg1;
23899   arg2 = (int)jarg2;
23900   arg3 = (int)jarg3;
23901   {
23902     try {
23903       (arg1)->SetIndexRange(arg2,arg3);
23904     } catch (std::out_of_range& e) {
23905       {
23906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23907       };
23908     } catch (std::exception& e) {
23909       {
23910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23911       };
23912     } catch (...) {
23913       {
23914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23915       };
23916     }
23917   }
23918 }
23919
23920
23921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
23922   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23923   Dali::TextureSet *arg2 = 0 ;
23924
23925   arg1 = (Dali::Renderer *)jarg1;
23926   arg2 = (Dali::TextureSet *)jarg2;
23927   if (!arg2) {
23928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
23929     return ;
23930   }
23931   {
23932     try {
23933       (arg1)->SetTextures(*arg2);
23934     } catch (std::out_of_range& e) {
23935       {
23936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23937       };
23938     } catch (std::exception& e) {
23939       {
23940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23941       };
23942     } catch (...) {
23943       {
23944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23945       };
23946     }
23947   }
23948 }
23949
23950
23951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
23952   void * jresult ;
23953   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23954   Dali::TextureSet result;
23955
23956   arg1 = (Dali::Renderer *)jarg1;
23957   {
23958     try {
23959       result = ((Dali::Renderer const *)arg1)->GetTextures();
23960     } catch (std::out_of_range& e) {
23961       {
23962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23963       };
23964     } catch (std::exception& e) {
23965       {
23966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23967       };
23968     } catch (...) {
23969       {
23970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23971       };
23972     }
23973   }
23974   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
23975   return jresult;
23976 }
23977
23978
23979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
23980   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23981   Dali::Shader *arg2 = 0 ;
23982
23983   arg1 = (Dali::Renderer *)jarg1;
23984   arg2 = (Dali::Shader *)jarg2;
23985   if (!arg2) {
23986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23987     return ;
23988   }
23989   {
23990     try {
23991       (arg1)->SetShader(*arg2);
23992     } catch (std::out_of_range& e) {
23993       {
23994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23995       };
23996     } catch (std::exception& e) {
23997       {
23998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23999       };
24000     } catch (...) {
24001       {
24002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24003       };
24004     }
24005   }
24006 }
24007
24008
24009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
24010   void * jresult ;
24011   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
24012   Dali::Shader result;
24013
24014   arg1 = (Dali::Renderer *)jarg1;
24015   {
24016     try {
24017       result = ((Dali::Renderer const *)arg1)->GetShader();
24018     } catch (std::out_of_range& e) {
24019       {
24020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24021       };
24022     } catch (std::exception& e) {
24023       {
24024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24025       };
24026     } catch (...) {
24027       {
24028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24029       };
24030     }
24031   }
24032   jresult = new Dali::Shader((const Dali::Shader &)result);
24033   return jresult;
24034 }
24035
24036
24037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
24038   void * jresult ;
24039   Dali::FrameBuffer::Attachment *result = 0 ;
24040
24041   {
24042     try {
24043       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
24044     } catch (std::out_of_range& e) {
24045       {
24046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24047       };
24048     } catch (std::exception& e) {
24049       {
24050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24051       };
24052     } catch (...) {
24053       {
24054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24055       };
24056     }
24057   }
24058   jresult = (void *)result;
24059   return jresult;
24060 }
24061
24062
24063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
24064   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
24065
24066   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
24067   {
24068     try {
24069       delete arg1;
24070     } catch (std::out_of_range& e) {
24071       {
24072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24073       };
24074     } catch (std::exception& e) {
24075       {
24076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24077       };
24078     } catch (...) {
24079       {
24080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24081       };
24082     }
24083   }
24084 }
24085
24086
24087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
24088   void * jresult ;
24089   unsigned int arg1 ;
24090   unsigned int arg2 ;
24091   unsigned int arg3 ;
24092   Dali::FrameBuffer result;
24093
24094   arg1 = (unsigned int)jarg1;
24095   arg2 = (unsigned int)jarg2;
24096   arg3 = (unsigned int)jarg3;
24097   {
24098     try {
24099       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
24100     } catch (std::out_of_range& e) {
24101       {
24102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24103       };
24104     } catch (std::exception& e) {
24105       {
24106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24107       };
24108     } catch (...) {
24109       {
24110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24111       };
24112     }
24113   }
24114   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24115   return jresult;
24116 }
24117
24118
24119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
24120   void * jresult ;
24121   Dali::FrameBuffer *result = 0 ;
24122
24123   {
24124     try {
24125       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
24126     } catch (std::out_of_range& e) {
24127       {
24128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24129       };
24130     } catch (std::exception& e) {
24131       {
24132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24133       };
24134     } catch (...) {
24135       {
24136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24137       };
24138     }
24139   }
24140   jresult = (void *)result;
24141   return jresult;
24142 }
24143
24144
24145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
24146   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24147
24148   arg1 = (Dali::FrameBuffer *)jarg1;
24149   {
24150     try {
24151       delete arg1;
24152     } catch (std::out_of_range& e) {
24153       {
24154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24155       };
24156     } catch (std::exception& e) {
24157       {
24158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24159       };
24160     } catch (...) {
24161       {
24162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24163       };
24164     }
24165   }
24166 }
24167
24168
24169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
24170   void * jresult ;
24171   Dali::FrameBuffer *arg1 = 0 ;
24172   Dali::FrameBuffer *result = 0 ;
24173
24174   arg1 = (Dali::FrameBuffer *)jarg1;
24175   if (!arg1) {
24176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24177     return 0;
24178   }
24179   {
24180     try {
24181       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
24182     } catch (std::out_of_range& e) {
24183       {
24184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24185       };
24186     } catch (std::exception& e) {
24187       {
24188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24189       };
24190     } catch (...) {
24191       {
24192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24193       };
24194     }
24195   }
24196   jresult = (void *)result;
24197   return jresult;
24198 }
24199
24200
24201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
24202   void * jresult ;
24203   Dali::BaseHandle arg1 ;
24204   Dali::BaseHandle *argp1 ;
24205   Dali::FrameBuffer result;
24206
24207   argp1 = (Dali::BaseHandle *)jarg1;
24208   if (!argp1) {
24209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24210     return 0;
24211   }
24212   arg1 = *argp1;
24213   {
24214     try {
24215       result = Dali::FrameBuffer::DownCast(arg1);
24216     } catch (std::out_of_range& e) {
24217       {
24218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24219       };
24220     } catch (std::exception& e) {
24221       {
24222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24223       };
24224     } catch (...) {
24225       {
24226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24227       };
24228     }
24229   }
24230   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24231   return jresult;
24232 }
24233
24234
24235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
24236   void * jresult ;
24237   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24238   Dali::FrameBuffer *arg2 = 0 ;
24239   Dali::FrameBuffer *result = 0 ;
24240
24241   arg1 = (Dali::FrameBuffer *)jarg1;
24242   arg2 = (Dali::FrameBuffer *)jarg2;
24243   if (!arg2) {
24244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24245     return 0;
24246   }
24247   {
24248     try {
24249       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
24250     } catch (std::out_of_range& e) {
24251       {
24252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24253       };
24254     } catch (std::exception& e) {
24255       {
24256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24257       };
24258     } catch (...) {
24259       {
24260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24261       };
24262     }
24263   }
24264   jresult = (void *)result;
24265   return jresult;
24266 }
24267
24268
24269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
24270   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24271   Dali::Texture *arg2 = 0 ;
24272
24273   arg1 = (Dali::FrameBuffer *)jarg1;
24274   arg2 = (Dali::Texture *)jarg2;
24275   if (!arg2) {
24276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24277     return ;
24278   }
24279   {
24280     try {
24281       (arg1)->AttachColorTexture(*arg2);
24282     } catch (std::out_of_range& e) {
24283       {
24284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24285       };
24286     } catch (std::exception& e) {
24287       {
24288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24289       };
24290     } catch (...) {
24291       {
24292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24293       };
24294     }
24295   }
24296 }
24297
24298
24299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
24300   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24301   Dali::Texture *arg2 = 0 ;
24302   unsigned int arg3 ;
24303   unsigned int arg4 ;
24304
24305   arg1 = (Dali::FrameBuffer *)jarg1;
24306   arg2 = (Dali::Texture *)jarg2;
24307   if (!arg2) {
24308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24309     return ;
24310   }
24311   arg3 = (unsigned int)jarg3;
24312   arg4 = (unsigned int)jarg4;
24313   {
24314     try {
24315       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
24316     } catch (std::out_of_range& e) {
24317       {
24318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24319       };
24320     } catch (std::exception& e) {
24321       {
24322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24323       };
24324     } catch (...) {
24325       {
24326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24327       };
24328     }
24329   }
24330 }
24331
24332
24333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
24334   void * jresult ;
24335   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24336   Dali::Texture result;
24337
24338   arg1 = (Dali::FrameBuffer *)jarg1;
24339   {
24340     try {
24341       result = (arg1)->GetColorTexture();
24342     } catch (std::out_of_range& e) {
24343       {
24344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24345       };
24346     } catch (std::exception& e) {
24347       {
24348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24349       };
24350     } catch (...) {
24351       {
24352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24353       };
24354     }
24355   }
24356   jresult = new Dali::Texture((const Dali::Texture &)result);
24357   return jresult;
24358 }
24359
24360
24361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
24362   void * jresult ;
24363   Dali::RenderTaskList *result = 0 ;
24364
24365   {
24366     try {
24367       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
24368     } catch (std::out_of_range& e) {
24369       {
24370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24371       };
24372     } catch (std::exception& e) {
24373       {
24374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24375       };
24376     } catch (...) {
24377       {
24378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24379       };
24380     }
24381   }
24382   jresult = (void *)result;
24383   return jresult;
24384 }
24385
24386
24387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
24388   void * jresult ;
24389   Dali::BaseHandle arg1 ;
24390   Dali::BaseHandle *argp1 ;
24391   Dali::RenderTaskList result;
24392
24393   argp1 = (Dali::BaseHandle *)jarg1;
24394   if (!argp1) {
24395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24396     return 0;
24397   }
24398   arg1 = *argp1;
24399   {
24400     try {
24401       result = Dali::RenderTaskList::DownCast(arg1);
24402     } catch (std::out_of_range& e) {
24403       {
24404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24405       };
24406     } catch (std::exception& e) {
24407       {
24408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24409       };
24410     } catch (...) {
24411       {
24412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24413       };
24414     }
24415   }
24416   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
24417   return jresult;
24418 }
24419
24420
24421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
24422   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24423
24424   arg1 = (Dali::RenderTaskList *)jarg1;
24425   {
24426     try {
24427       delete arg1;
24428     } catch (std::out_of_range& e) {
24429       {
24430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24431       };
24432     } catch (std::exception& e) {
24433       {
24434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24435       };
24436     } catch (...) {
24437       {
24438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24439       };
24440     }
24441   }
24442 }
24443
24444
24445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
24446   void * jresult ;
24447   Dali::RenderTaskList *arg1 = 0 ;
24448   Dali::RenderTaskList *result = 0 ;
24449
24450   arg1 = (Dali::RenderTaskList *)jarg1;
24451   if (!arg1) {
24452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24453     return 0;
24454   }
24455   {
24456     try {
24457       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
24458     } catch (std::out_of_range& e) {
24459       {
24460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24461       };
24462     } catch (std::exception& e) {
24463       {
24464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24465       };
24466     } catch (...) {
24467       {
24468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24469       };
24470     }
24471   }
24472   jresult = (void *)result;
24473   return jresult;
24474 }
24475
24476
24477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
24478   void * jresult ;
24479   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24480   Dali::RenderTaskList *arg2 = 0 ;
24481   Dali::RenderTaskList *result = 0 ;
24482
24483   arg1 = (Dali::RenderTaskList *)jarg1;
24484   arg2 = (Dali::RenderTaskList *)jarg2;
24485   if (!arg2) {
24486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24487     return 0;
24488   }
24489   {
24490     try {
24491       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
24492     } catch (std::out_of_range& e) {
24493       {
24494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24495       };
24496     } catch (std::exception& e) {
24497       {
24498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24499       };
24500     } catch (...) {
24501       {
24502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24503       };
24504     }
24505   }
24506   jresult = (void *)result;
24507   return jresult;
24508 }
24509
24510
24511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
24512   void * jresult ;
24513   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24514   Dali::RenderTask result;
24515
24516   arg1 = (Dali::RenderTaskList *)jarg1;
24517   {
24518     try {
24519       result = (arg1)->CreateTask();
24520     } catch (std::out_of_range& e) {
24521       {
24522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24523       };
24524     } catch (std::exception& e) {
24525       {
24526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24527       };
24528     } catch (...) {
24529       {
24530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24531       };
24532     }
24533   }
24534   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24535   return jresult;
24536 }
24537
24538
24539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
24540   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24541   Dali::RenderTask arg2 ;
24542   Dali::RenderTask *argp2 ;
24543
24544   arg1 = (Dali::RenderTaskList *)jarg1;
24545   argp2 = (Dali::RenderTask *)jarg2;
24546   if (!argp2) {
24547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
24548     return ;
24549   }
24550   arg2 = *argp2;
24551   {
24552     try {
24553       (arg1)->RemoveTask(arg2);
24554     } catch (std::out_of_range& e) {
24555       {
24556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24557       };
24558     } catch (std::exception& e) {
24559       {
24560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24561       };
24562     } catch (...) {
24563       {
24564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24565       };
24566     }
24567   }
24568 }
24569
24570
24571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
24572   unsigned int jresult ;
24573   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24574   unsigned int result;
24575
24576   arg1 = (Dali::RenderTaskList *)jarg1;
24577   {
24578     try {
24579       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
24580     } catch (std::out_of_range& e) {
24581       {
24582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24583       };
24584     } catch (std::exception& e) {
24585       {
24586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24587       };
24588     } catch (...) {
24589       {
24590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24591       };
24592     }
24593   }
24594   jresult = result;
24595   return jresult;
24596 }
24597
24598
24599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
24600   void * jresult ;
24601   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24602   unsigned int arg2 ;
24603   Dali::RenderTask result;
24604
24605   arg1 = (Dali::RenderTaskList *)jarg1;
24606   arg2 = (unsigned int)jarg2;
24607   {
24608     try {
24609       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
24610     } catch (std::out_of_range& e) {
24611       {
24612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24613       };
24614     } catch (std::exception& e) {
24615       {
24616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24617       };
24618     } catch (...) {
24619       {
24620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24621       };
24622     }
24623   }
24624   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24625   return jresult;
24626 }
24627
24628
24629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
24630   int jresult ;
24631   int result;
24632
24633   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
24634   jresult = (int)result;
24635   return jresult;
24636 }
24637
24638
24639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
24640   int jresult ;
24641   int result;
24642
24643   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
24644   jresult = (int)result;
24645   return jresult;
24646 }
24647
24648
24649 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
24650   int jresult ;
24651   int result;
24652
24653   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
24654   jresult = (int)result;
24655   return jresult;
24656 }
24657
24658
24659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
24660   int jresult ;
24661   int result;
24662
24663   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
24664   jresult = (int)result;
24665   return jresult;
24666 }
24667
24668
24669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
24670   void * jresult ;
24671   Dali::RenderTask::Property *result = 0 ;
24672
24673   {
24674     try {
24675       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
24676     } catch (std::out_of_range& e) {
24677       {
24678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24679       };
24680     } catch (std::exception& e) {
24681       {
24682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24683       };
24684     } catch (...) {
24685       {
24686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24687       };
24688     }
24689   }
24690   jresult = (void *)result;
24691   return jresult;
24692 }
24693
24694
24695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
24696   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
24697
24698   arg1 = (Dali::RenderTask::Property *)jarg1;
24699   {
24700     try {
24701       delete arg1;
24702     } catch (std::out_of_range& e) {
24703       {
24704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24705       };
24706     } catch (std::exception& e) {
24707       {
24708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24709       };
24710     } catch (...) {
24711       {
24712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24713       };
24714     }
24715   }
24716 }
24717
24718
24719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
24720   void * jresult ;
24721   bool (*result)(Dali::Vector2 &) = 0 ;
24722
24723   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
24724   jresult = (void *)result;
24725   return jresult;
24726 }
24727
24728
24729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
24730   void * jresult ;
24731   bool (*result)(Dali::Vector2 &) = 0 ;
24732
24733   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
24734   jresult = (void *)result;
24735   return jresult;
24736 }
24737
24738
24739 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
24740   unsigned int jresult ;
24741   bool result;
24742
24743   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
24744   jresult = result;
24745   return jresult;
24746 }
24747
24748
24749 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
24750   unsigned int jresult ;
24751   bool result;
24752
24753   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
24754   jresult = result;
24755   return jresult;
24756 }
24757
24758
24759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
24760   void * jresult ;
24761   Dali::Vector4 *result = 0 ;
24762
24763   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
24764   jresult = (void *)result;
24765   return jresult;
24766 }
24767
24768
24769 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
24770   unsigned int jresult ;
24771   bool result;
24772
24773   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
24774   jresult = result;
24775   return jresult;
24776 }
24777
24778
24779 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
24780   unsigned int jresult ;
24781   bool result;
24782
24783   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
24784   jresult = result;
24785   return jresult;
24786 }
24787
24788
24789 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
24790   unsigned int jresult ;
24791   unsigned int result;
24792
24793   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
24794   jresult = result;
24795   return jresult;
24796 }
24797
24798
24799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
24800   void * jresult ;
24801   Dali::RenderTask *result = 0 ;
24802
24803   {
24804     try {
24805       result = (Dali::RenderTask *)new Dali::RenderTask();
24806     } catch (std::out_of_range& e) {
24807       {
24808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24809       };
24810     } catch (std::exception& e) {
24811       {
24812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24813       };
24814     } catch (...) {
24815       {
24816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24817       };
24818     }
24819   }
24820   jresult = (void *)result;
24821   return jresult;
24822 }
24823
24824
24825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
24826   void * jresult ;
24827   Dali::BaseHandle arg1 ;
24828   Dali::BaseHandle *argp1 ;
24829   Dali::RenderTask result;
24830
24831   argp1 = (Dali::BaseHandle *)jarg1;
24832   if (!argp1) {
24833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24834     return 0;
24835   }
24836   arg1 = *argp1;
24837   {
24838     try {
24839       result = Dali::RenderTask::DownCast(arg1);
24840     } catch (std::out_of_range& e) {
24841       {
24842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24843       };
24844     } catch (std::exception& e) {
24845       {
24846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24847       };
24848     } catch (...) {
24849       {
24850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24851       };
24852     }
24853   }
24854   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24855   return jresult;
24856 }
24857
24858
24859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
24860   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24861
24862   arg1 = (Dali::RenderTask *)jarg1;
24863   {
24864     try {
24865       delete arg1;
24866     } catch (std::out_of_range& e) {
24867       {
24868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24869       };
24870     } catch (std::exception& e) {
24871       {
24872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24873       };
24874     } catch (...) {
24875       {
24876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24877       };
24878     }
24879   }
24880 }
24881
24882
24883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
24884   void * jresult ;
24885   Dali::RenderTask *arg1 = 0 ;
24886   Dali::RenderTask *result = 0 ;
24887
24888   arg1 = (Dali::RenderTask *)jarg1;
24889   if (!arg1) {
24890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24891     return 0;
24892   }
24893   {
24894     try {
24895       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
24896     } catch (std::out_of_range& e) {
24897       {
24898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24899       };
24900     } catch (std::exception& e) {
24901       {
24902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24903       };
24904     } catch (...) {
24905       {
24906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24907       };
24908     }
24909   }
24910   jresult = (void *)result;
24911   return jresult;
24912 }
24913
24914
24915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
24916   void * jresult ;
24917   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24918   Dali::RenderTask *arg2 = 0 ;
24919   Dali::RenderTask *result = 0 ;
24920
24921   arg1 = (Dali::RenderTask *)jarg1;
24922   arg2 = (Dali::RenderTask *)jarg2;
24923   if (!arg2) {
24924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24925     return 0;
24926   }
24927   {
24928     try {
24929       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
24930     } catch (std::out_of_range& e) {
24931       {
24932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24933       };
24934     } catch (std::exception& e) {
24935       {
24936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24937       };
24938     } catch (...) {
24939       {
24940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24941       };
24942     }
24943   }
24944   jresult = (void *)result;
24945   return jresult;
24946 }
24947
24948
24949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
24950   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24951   Dali::Actor arg2 ;
24952   Dali::Actor *argp2 ;
24953
24954   arg1 = (Dali::RenderTask *)jarg1;
24955   argp2 = (Dali::Actor *)jarg2;
24956   if (!argp2) {
24957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24958     return ;
24959   }
24960   arg2 = *argp2;
24961   {
24962     try {
24963       (arg1)->SetSourceActor(arg2);
24964     } catch (std::out_of_range& e) {
24965       {
24966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24967       };
24968     } catch (std::exception& e) {
24969       {
24970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24971       };
24972     } catch (...) {
24973       {
24974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24975       };
24976     }
24977   }
24978 }
24979
24980
24981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
24982   void * jresult ;
24983   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24984   Dali::Actor result;
24985
24986   arg1 = (Dali::RenderTask *)jarg1;
24987   {
24988     try {
24989       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
24990     } catch (std::out_of_range& e) {
24991       {
24992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24993       };
24994     } catch (std::exception& e) {
24995       {
24996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24997       };
24998     } catch (...) {
24999       {
25000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25001       };
25002     }
25003   }
25004   jresult = new Dali::Actor((const Dali::Actor &)result);
25005   return jresult;
25006 }
25007
25008
25009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
25010   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25011   bool arg2 ;
25012
25013   arg1 = (Dali::RenderTask *)jarg1;
25014   arg2 = jarg2 ? true : false;
25015   {
25016     try {
25017       (arg1)->SetExclusive(arg2);
25018     } catch (std::out_of_range& e) {
25019       {
25020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25021       };
25022     } catch (std::exception& e) {
25023       {
25024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25025       };
25026     } catch (...) {
25027       {
25028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25029       };
25030     }
25031   }
25032 }
25033
25034
25035 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
25036   unsigned int jresult ;
25037   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25038   bool result;
25039
25040   arg1 = (Dali::RenderTask *)jarg1;
25041   {
25042     try {
25043       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
25044     } catch (std::out_of_range& e) {
25045       {
25046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25047       };
25048     } catch (std::exception& e) {
25049       {
25050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25051       };
25052     } catch (...) {
25053       {
25054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25055       };
25056     }
25057   }
25058   jresult = result;
25059   return jresult;
25060 }
25061
25062
25063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
25064   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25065   bool arg2 ;
25066
25067   arg1 = (Dali::RenderTask *)jarg1;
25068   arg2 = jarg2 ? true : false;
25069   {
25070     try {
25071       (arg1)->SetInputEnabled(arg2);
25072     } catch (std::out_of_range& e) {
25073       {
25074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25075       };
25076     } catch (std::exception& e) {
25077       {
25078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25079       };
25080     } catch (...) {
25081       {
25082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25083       };
25084     }
25085   }
25086 }
25087
25088
25089 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
25090   unsigned int jresult ;
25091   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25092   bool result;
25093
25094   arg1 = (Dali::RenderTask *)jarg1;
25095   {
25096     try {
25097       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
25098     } catch (std::out_of_range& e) {
25099       {
25100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25101       };
25102     } catch (std::exception& e) {
25103       {
25104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25105       };
25106     } catch (...) {
25107       {
25108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25109       };
25110     }
25111   }
25112   jresult = result;
25113   return jresult;
25114 }
25115
25116
25117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
25118   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25119   Dali::CameraActor arg2 ;
25120   Dali::CameraActor *argp2 ;
25121
25122   arg1 = (Dali::RenderTask *)jarg1;
25123   argp2 = (Dali::CameraActor *)jarg2;
25124   if (!argp2) {
25125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
25126     return ;
25127   }
25128   arg2 = *argp2;
25129   {
25130     try {
25131       (arg1)->SetCameraActor(arg2);
25132     } catch (std::out_of_range& e) {
25133       {
25134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25135       };
25136     } catch (std::exception& e) {
25137       {
25138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25139       };
25140     } catch (...) {
25141       {
25142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25143       };
25144     }
25145   }
25146 }
25147
25148
25149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
25150   void * jresult ;
25151   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25152   Dali::CameraActor result;
25153
25154   arg1 = (Dali::RenderTask *)jarg1;
25155   {
25156     try {
25157       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
25158     } catch (std::out_of_range& e) {
25159       {
25160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25161       };
25162     } catch (std::exception& e) {
25163       {
25164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25165       };
25166     } catch (...) {
25167       {
25168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25169       };
25170     }
25171   }
25172   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
25173   return jresult;
25174 }
25175
25176
25177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
25178   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25179   Dali::FrameBufferImage arg2 ;
25180   Dali::FrameBufferImage *argp2 ;
25181
25182   arg1 = (Dali::RenderTask *)jarg1;
25183   argp2 = (Dali::FrameBufferImage *)jarg2;
25184   if (!argp2) {
25185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
25186     return ;
25187   }
25188   arg2 = *argp2;
25189   {
25190     try {
25191       (arg1)->SetTargetFrameBuffer(arg2);
25192     } catch (std::out_of_range& e) {
25193       {
25194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25195       };
25196     } catch (std::exception& e) {
25197       {
25198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25199       };
25200     } catch (...) {
25201       {
25202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25203       };
25204     }
25205   }
25206 }
25207
25208
25209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
25210   void * jresult ;
25211   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25212   Dali::FrameBufferImage result;
25213
25214   arg1 = (Dali::RenderTask *)jarg1;
25215   {
25216     try {
25217       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
25218     } catch (std::out_of_range& e) {
25219       {
25220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25221       };
25222     } catch (std::exception& e) {
25223       {
25224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25225       };
25226     } catch (...) {
25227       {
25228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25229       };
25230     }
25231   }
25232   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
25233   return jresult;
25234 }
25235
25236
25237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
25238   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25239   Dali::FrameBuffer arg2 ;
25240   Dali::FrameBuffer *argp2 ;
25241
25242   arg1 = (Dali::RenderTask *)jarg1;
25243   argp2 = (Dali::FrameBuffer *)jarg2;
25244   if (!argp2) {
25245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
25246     return ;
25247   }
25248   arg2 = *argp2;
25249   {
25250     try {
25251       (arg1)->SetFrameBuffer(arg2);
25252     } catch (std::out_of_range& e) {
25253       {
25254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25255       };
25256     } catch (std::exception& e) {
25257       {
25258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25259       };
25260     } catch (...) {
25261       {
25262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25263       };
25264     }
25265   }
25266 }
25267
25268
25269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
25270   void * jresult ;
25271   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25272   Dali::FrameBuffer result;
25273
25274   arg1 = (Dali::RenderTask *)jarg1;
25275   {
25276     try {
25277       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
25278     } catch (std::out_of_range& e) {
25279       {
25280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25281       };
25282     } catch (std::exception& e) {
25283       {
25284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25285       };
25286     } catch (...) {
25287       {
25288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25289       };
25290     }
25291   }
25292   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
25293   return jresult;
25294 }
25295
25296
25297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
25298   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25299   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
25300
25301   arg1 = (Dali::RenderTask *)jarg1;
25302   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
25303   {
25304     try {
25305       (arg1)->SetScreenToFrameBufferFunction(arg2);
25306     } catch (std::out_of_range& e) {
25307       {
25308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25309       };
25310     } catch (std::exception& e) {
25311       {
25312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25313       };
25314     } catch (...) {
25315       {
25316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25317       };
25318     }
25319   }
25320 }
25321
25322
25323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
25324   void * jresult ;
25325   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25326   Dali::RenderTask::ScreenToFrameBufferFunction result;
25327
25328   arg1 = (Dali::RenderTask *)jarg1;
25329   {
25330     try {
25331       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
25332     } catch (std::out_of_range& e) {
25333       {
25334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25335       };
25336     } catch (std::exception& e) {
25337       {
25338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25339       };
25340     } catch (...) {
25341       {
25342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25343       };
25344     }
25345   }
25346   jresult = (void *)result;
25347   return jresult;
25348 }
25349
25350
25351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
25352   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25353   Dali::Actor arg2 ;
25354   Dali::Actor *argp2 ;
25355
25356   arg1 = (Dali::RenderTask *)jarg1;
25357   argp2 = (Dali::Actor *)jarg2;
25358   if (!argp2) {
25359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25360     return ;
25361   }
25362   arg2 = *argp2;
25363   {
25364     try {
25365       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
25366     } catch (std::out_of_range& e) {
25367       {
25368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25369       };
25370     } catch (std::exception& e) {
25371       {
25372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25373       };
25374     } catch (...) {
25375       {
25376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25377       };
25378     }
25379   }
25380 }
25381
25382
25383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
25384   void * jresult ;
25385   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25386   Dali::Actor result;
25387
25388   arg1 = (Dali::RenderTask *)jarg1;
25389   {
25390     try {
25391       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
25392     } catch (std::out_of_range& e) {
25393       {
25394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25395       };
25396     } catch (std::exception& e) {
25397       {
25398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25399       };
25400     } catch (...) {
25401       {
25402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25403       };
25404     }
25405   }
25406   jresult = new Dali::Actor((const Dali::Actor &)result);
25407   return jresult;
25408 }
25409
25410
25411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
25412   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25413   Dali::Vector2 arg2 ;
25414   Dali::Vector2 *argp2 ;
25415
25416   arg1 = (Dali::RenderTask *)jarg1;
25417   argp2 = (Dali::Vector2 *)jarg2;
25418   if (!argp2) {
25419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25420     return ;
25421   }
25422   arg2 = *argp2;
25423   {
25424     try {
25425       (arg1)->SetViewportPosition(arg2);
25426     } catch (std::out_of_range& e) {
25427       {
25428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25429       };
25430     } catch (std::exception& e) {
25431       {
25432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25433       };
25434     } catch (...) {
25435       {
25436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25437       };
25438     }
25439   }
25440 }
25441
25442
25443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
25444   void * jresult ;
25445   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25446   Dali::Vector2 result;
25447
25448   arg1 = (Dali::RenderTask *)jarg1;
25449   {
25450     try {
25451       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
25452     } catch (std::out_of_range& e) {
25453       {
25454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25455       };
25456     } catch (std::exception& e) {
25457       {
25458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25459       };
25460     } catch (...) {
25461       {
25462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25463       };
25464     }
25465   }
25466   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25467   return jresult;
25468 }
25469
25470
25471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
25472   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25473   Dali::Vector2 arg2 ;
25474   Dali::Vector2 *argp2 ;
25475
25476   arg1 = (Dali::RenderTask *)jarg1;
25477   argp2 = (Dali::Vector2 *)jarg2;
25478   if (!argp2) {
25479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25480     return ;
25481   }
25482   arg2 = *argp2;
25483   {
25484     try {
25485       (arg1)->SetViewportSize(arg2);
25486     } catch (std::out_of_range& e) {
25487       {
25488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25489       };
25490     } catch (std::exception& e) {
25491       {
25492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25493       };
25494     } catch (...) {
25495       {
25496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25497       };
25498     }
25499   }
25500 }
25501
25502
25503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
25504   void * jresult ;
25505   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25506   Dali::Vector2 result;
25507
25508   arg1 = (Dali::RenderTask *)jarg1;
25509   {
25510     try {
25511       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
25512     } catch (std::out_of_range& e) {
25513       {
25514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25515       };
25516     } catch (std::exception& e) {
25517       {
25518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25519       };
25520     } catch (...) {
25521       {
25522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25523       };
25524     }
25525   }
25526   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25527   return jresult;
25528 }
25529
25530
25531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
25532   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25533   Dali::Viewport arg2 ;
25534   Dali::Viewport *argp2 ;
25535
25536   arg1 = (Dali::RenderTask *)jarg1;
25537   argp2 = (Dali::Viewport *)jarg2;
25538   if (!argp2) {
25539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
25540     return ;
25541   }
25542   arg2 = *argp2;
25543   {
25544     try {
25545       (arg1)->SetViewport(arg2);
25546     } catch (std::out_of_range& e) {
25547       {
25548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25549       };
25550     } catch (std::exception& e) {
25551       {
25552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25553       };
25554     } catch (...) {
25555       {
25556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25557       };
25558     }
25559   }
25560 }
25561
25562
25563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
25564   void * jresult ;
25565   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25566   Dali::Viewport result;
25567
25568   arg1 = (Dali::RenderTask *)jarg1;
25569   {
25570     try {
25571       result = ((Dali::RenderTask const *)arg1)->GetViewport();
25572     } catch (std::out_of_range& e) {
25573       {
25574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25575       };
25576     } catch (std::exception& e) {
25577       {
25578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25579       };
25580     } catch (...) {
25581       {
25582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25583       };
25584     }
25585   }
25586   jresult = new Dali::Viewport((const Dali::Viewport &)result);
25587   return jresult;
25588 }
25589
25590
25591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
25592   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25593   Dali::Vector4 *arg2 = 0 ;
25594
25595   arg1 = (Dali::RenderTask *)jarg1;
25596   arg2 = (Dali::Vector4 *)jarg2;
25597   if (!arg2) {
25598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
25599     return ;
25600   }
25601   {
25602     try {
25603       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
25604     } catch (std::out_of_range& e) {
25605       {
25606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25607       };
25608     } catch (std::exception& e) {
25609       {
25610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25611       };
25612     } catch (...) {
25613       {
25614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25615       };
25616     }
25617   }
25618 }
25619
25620
25621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
25622   void * jresult ;
25623   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25624   Dali::Vector4 result;
25625
25626   arg1 = (Dali::RenderTask *)jarg1;
25627   {
25628     try {
25629       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
25630     } catch (std::out_of_range& e) {
25631       {
25632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25633       };
25634     } catch (std::exception& e) {
25635       {
25636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25637       };
25638     } catch (...) {
25639       {
25640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25641       };
25642     }
25643   }
25644   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
25645   return jresult;
25646 }
25647
25648
25649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
25650   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25651   bool arg2 ;
25652
25653   arg1 = (Dali::RenderTask *)jarg1;
25654   arg2 = jarg2 ? true : false;
25655   {
25656     try {
25657       (arg1)->SetClearEnabled(arg2);
25658     } catch (std::out_of_range& e) {
25659       {
25660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25661       };
25662     } catch (std::exception& e) {
25663       {
25664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25665       };
25666     } catch (...) {
25667       {
25668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25669       };
25670     }
25671   }
25672 }
25673
25674
25675 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
25676   unsigned int jresult ;
25677   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25678   bool result;
25679
25680   arg1 = (Dali::RenderTask *)jarg1;
25681   {
25682     try {
25683       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
25684     } catch (std::out_of_range& e) {
25685       {
25686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25687       };
25688     } catch (std::exception& e) {
25689       {
25690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25691       };
25692     } catch (...) {
25693       {
25694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25695       };
25696     }
25697   }
25698   jresult = result;
25699   return jresult;
25700 }
25701
25702
25703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
25704   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25705   bool arg2 ;
25706
25707   arg1 = (Dali::RenderTask *)jarg1;
25708   arg2 = jarg2 ? true : false;
25709   {
25710     try {
25711       (arg1)->SetCullMode(arg2);
25712     } catch (std::out_of_range& e) {
25713       {
25714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25715       };
25716     } catch (std::exception& e) {
25717       {
25718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25719       };
25720     } catch (...) {
25721       {
25722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25723       };
25724     }
25725   }
25726 }
25727
25728
25729 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
25730   unsigned int jresult ;
25731   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25732   bool result;
25733
25734   arg1 = (Dali::RenderTask *)jarg1;
25735   {
25736     try {
25737       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
25738     } catch (std::out_of_range& e) {
25739       {
25740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25741       };
25742     } catch (std::exception& e) {
25743       {
25744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25745       };
25746     } catch (...) {
25747       {
25748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25749       };
25750     }
25751   }
25752   jresult = result;
25753   return jresult;
25754 }
25755
25756
25757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
25758   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25759   unsigned int arg2 ;
25760
25761   arg1 = (Dali::RenderTask *)jarg1;
25762   arg2 = (unsigned int)jarg2;
25763   {
25764     try {
25765       (arg1)->SetRefreshRate(arg2);
25766     } catch (std::out_of_range& e) {
25767       {
25768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25769       };
25770     } catch (std::exception& e) {
25771       {
25772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25773       };
25774     } catch (...) {
25775       {
25776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25777       };
25778     }
25779   }
25780 }
25781
25782
25783 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
25784   unsigned int jresult ;
25785   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25786   unsigned int result;
25787
25788   arg1 = (Dali::RenderTask *)jarg1;
25789   {
25790     try {
25791       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
25792     } catch (std::out_of_range& e) {
25793       {
25794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25795       };
25796     } catch (std::exception& e) {
25797       {
25798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25799       };
25800     } catch (...) {
25801       {
25802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25803       };
25804     }
25805   }
25806   jresult = result;
25807   return jresult;
25808 }
25809
25810
25811 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
25812   unsigned int jresult ;
25813   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25814   Dali::Vector3 *arg2 = 0 ;
25815   float *arg3 = 0 ;
25816   float *arg4 = 0 ;
25817   bool result;
25818
25819   arg1 = (Dali::RenderTask *)jarg1;
25820   arg2 = (Dali::Vector3 *)jarg2;
25821   if (!arg2) {
25822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
25823     return 0;
25824   }
25825   arg3 = (float *)jarg3;
25826   arg4 = (float *)jarg4;
25827   {
25828     try {
25829       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
25830     } catch (std::out_of_range& e) {
25831       {
25832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25833       };
25834     } catch (std::exception& e) {
25835       {
25836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25837       };
25838     } catch (...) {
25839       {
25840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25841       };
25842     }
25843   }
25844   jresult = result;
25845   return jresult;
25846 }
25847
25848
25849 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
25850   unsigned int jresult ;
25851   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25852   Dali::Actor arg2 ;
25853   float arg3 ;
25854   float arg4 ;
25855   float *arg5 = 0 ;
25856   float *arg6 = 0 ;
25857   Dali::Actor *argp2 ;
25858   bool result;
25859
25860   arg1 = (Dali::RenderTask *)jarg1;
25861   argp2 = (Dali::Actor *)jarg2;
25862   if (!argp2) {
25863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25864     return 0;
25865   }
25866   arg2 = *argp2;
25867   arg3 = (float)jarg3;
25868   arg4 = (float)jarg4;
25869   arg5 = (float *)jarg5;
25870   arg6 = (float *)jarg6;
25871   {
25872     try {
25873       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
25874     } catch (std::out_of_range& e) {
25875       {
25876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25877       };
25878     } catch (std::exception& e) {
25879       {
25880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25881       };
25882     } catch (...) {
25883       {
25884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25885       };
25886     }
25887   }
25888   jresult = result;
25889   return jresult;
25890 }
25891
25892
25893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
25894   void * jresult ;
25895   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25896   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
25897
25898   arg1 = (Dali::RenderTask *)jarg1;
25899   {
25900     try {
25901       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
25902     } catch (std::out_of_range& e) {
25903       {
25904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25905       };
25906     } catch (std::exception& e) {
25907       {
25908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25909       };
25910     } catch (...) {
25911       {
25912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25913       };
25914     }
25915   }
25916   jresult = (void *)result;
25917   return jresult;
25918 }
25919
25920
25921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
25922   void * jresult ;
25923   int arg1 ;
25924   Dali::TouchPoint::State arg2 ;
25925   float arg3 ;
25926   float arg4 ;
25927   Dali::TouchPoint *result = 0 ;
25928
25929   arg1 = (int)jarg1;
25930   arg2 = (Dali::TouchPoint::State)jarg2;
25931   arg3 = (float)jarg3;
25932   arg4 = (float)jarg4;
25933   {
25934     try {
25935       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
25936     } catch (std::out_of_range& e) {
25937       {
25938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25939       };
25940     } catch (std::exception& e) {
25941       {
25942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25943       };
25944     } catch (...) {
25945       {
25946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25947       };
25948     }
25949   }
25950   jresult = (void *)result;
25951   return jresult;
25952 }
25953
25954
25955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
25956   void * jresult ;
25957   int arg1 ;
25958   Dali::TouchPoint::State arg2 ;
25959   float arg3 ;
25960   float arg4 ;
25961   float arg5 ;
25962   float arg6 ;
25963   Dali::TouchPoint *result = 0 ;
25964
25965   arg1 = (int)jarg1;
25966   arg2 = (Dali::TouchPoint::State)jarg2;
25967   arg3 = (float)jarg3;
25968   arg4 = (float)jarg4;
25969   arg5 = (float)jarg5;
25970   arg6 = (float)jarg6;
25971   {
25972     try {
25973       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
25974     } catch (std::out_of_range& e) {
25975       {
25976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25977       };
25978     } catch (std::exception& e) {
25979       {
25980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25981       };
25982     } catch (...) {
25983       {
25984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25985       };
25986     }
25987   }
25988   jresult = (void *)result;
25989   return jresult;
25990 }
25991
25992
25993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
25994   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25995
25996   arg1 = (Dali::TouchPoint *)jarg1;
25997   {
25998     try {
25999       delete arg1;
26000     } catch (std::out_of_range& e) {
26001       {
26002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26003       };
26004     } catch (std::exception& e) {
26005       {
26006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26007       };
26008     } catch (...) {
26009       {
26010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26011       };
26012     }
26013   }
26014 }
26015
26016
26017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
26018   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26019   int arg2 ;
26020
26021   arg1 = (Dali::TouchPoint *)jarg1;
26022   arg2 = (int)jarg2;
26023   if (arg1) (arg1)->deviceId = arg2;
26024 }
26025
26026
26027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
26028   int jresult ;
26029   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26030   int result;
26031
26032   arg1 = (Dali::TouchPoint *)jarg1;
26033   result = (int) ((arg1)->deviceId);
26034   jresult = result;
26035   return jresult;
26036 }
26037
26038
26039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
26040   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26041   Dali::TouchPoint::State arg2 ;
26042
26043   arg1 = (Dali::TouchPoint *)jarg1;
26044   arg2 = (Dali::TouchPoint::State)jarg2;
26045   if (arg1) (arg1)->state = arg2;
26046 }
26047
26048
26049 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
26050   int jresult ;
26051   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26052   Dali::TouchPoint::State result;
26053
26054   arg1 = (Dali::TouchPoint *)jarg1;
26055   result = (Dali::TouchPoint::State) ((arg1)->state);
26056   jresult = (int)result;
26057   return jresult;
26058 }
26059
26060
26061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
26062   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26063   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
26064
26065   arg1 = (Dali::TouchPoint *)jarg1;
26066   arg2 = (Dali::Actor *)jarg2;
26067   if (arg1) (arg1)->hitActor = *arg2;
26068 }
26069
26070
26071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
26072   void * jresult ;
26073   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26074   Dali::Actor *result = 0 ;
26075
26076   arg1 = (Dali::TouchPoint *)jarg1;
26077   result = (Dali::Actor *)& ((arg1)->hitActor);
26078   jresult = (void *)result;
26079   return jresult;
26080 }
26081
26082
26083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
26084   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26085   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26086
26087   arg1 = (Dali::TouchPoint *)jarg1;
26088   arg2 = (Dali::Vector2 *)jarg2;
26089   if (arg1) (arg1)->local = *arg2;
26090 }
26091
26092
26093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
26094   void * jresult ;
26095   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26096   Dali::Vector2 *result = 0 ;
26097
26098   arg1 = (Dali::TouchPoint *)jarg1;
26099   result = (Dali::Vector2 *)& ((arg1)->local);
26100   jresult = (void *)result;
26101   return jresult;
26102 }
26103
26104
26105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
26106   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26107   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26108
26109   arg1 = (Dali::TouchPoint *)jarg1;
26110   arg2 = (Dali::Vector2 *)jarg2;
26111   if (arg1) (arg1)->screen = *arg2;
26112 }
26113
26114
26115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
26116   void * jresult ;
26117   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26118   Dali::Vector2 *result = 0 ;
26119
26120   arg1 = (Dali::TouchPoint *)jarg1;
26121   result = (Dali::Vector2 *)& ((arg1)->screen);
26122   jresult = (void *)result;
26123   return jresult;
26124 }
26125
26126
26127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
26128   void * jresult ;
26129   Dali::TouchData *result = 0 ;
26130
26131   {
26132     try {
26133       result = (Dali::TouchData *)new Dali::TouchData();
26134     } catch (std::out_of_range& e) {
26135       {
26136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26137       };
26138     } catch (std::exception& e) {
26139       {
26140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26141       };
26142     } catch (...) {
26143       {
26144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26145       };
26146     }
26147   }
26148   jresult = (void *)result;
26149   return jresult;
26150 }
26151
26152
26153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
26154   void * jresult ;
26155   Dali::TouchData *arg1 = 0 ;
26156   Dali::TouchData *result = 0 ;
26157
26158   arg1 = (Dali::TouchData *)jarg1;
26159   if (!arg1) {
26160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26161     return 0;
26162   }
26163   {
26164     try {
26165       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
26166     } catch (std::out_of_range& e) {
26167       {
26168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26169       };
26170     } catch (std::exception& e) {
26171       {
26172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26173       };
26174     } catch (...) {
26175       {
26176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26177       };
26178     }
26179   }
26180   jresult = (void *)result;
26181   return jresult;
26182 }
26183
26184
26185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
26186   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26187
26188   arg1 = (Dali::TouchData *)jarg1;
26189   {
26190     try {
26191       delete arg1;
26192     } catch (std::out_of_range& e) {
26193       {
26194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26195       };
26196     } catch (std::exception& e) {
26197       {
26198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26199       };
26200     } catch (...) {
26201       {
26202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26203       };
26204     }
26205   }
26206 }
26207
26208
26209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
26210   void * jresult ;
26211   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26212   Dali::TouchData *arg2 = 0 ;
26213   Dali::TouchData *result = 0 ;
26214
26215   arg1 = (Dali::TouchData *)jarg1;
26216   arg2 = (Dali::TouchData *)jarg2;
26217   if (!arg2) {
26218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26219     return 0;
26220   }
26221   {
26222     try {
26223       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
26224     } catch (std::out_of_range& e) {
26225       {
26226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26227       };
26228     } catch (std::exception& e) {
26229       {
26230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26231       };
26232     } catch (...) {
26233       {
26234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26235       };
26236     }
26237   }
26238   jresult = (void *)result;
26239   return jresult;
26240 }
26241
26242
26243 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
26244   unsigned long jresult ;
26245   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26246   unsigned long result;
26247
26248   arg1 = (Dali::TouchData *)jarg1;
26249   {
26250     try {
26251       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
26252     } catch (std::out_of_range& e) {
26253       {
26254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26255       };
26256     } catch (std::exception& e) {
26257       {
26258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26259       };
26260     } catch (...) {
26261       {
26262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26263       };
26264     }
26265   }
26266   jresult = (unsigned long)result;
26267   return jresult;
26268 }
26269
26270
26271 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
26272   unsigned long jresult ;
26273   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26274   std::size_t result;
26275
26276   arg1 = (Dali::TouchData *)jarg1;
26277   {
26278     try {
26279       result = ((Dali::TouchData const *)arg1)->GetPointCount();
26280     } catch (std::out_of_range& e) {
26281       {
26282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26283       };
26284     } catch (std::exception& e) {
26285       {
26286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26287       };
26288     } catch (...) {
26289       {
26290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26291       };
26292     }
26293   }
26294   jresult = (unsigned long)result;
26295   return jresult;
26296 }
26297
26298
26299 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
26300   int jresult ;
26301   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26302   std::size_t arg2 ;
26303   int32_t result;
26304
26305   arg1 = (Dali::TouchData *)jarg1;
26306   arg2 = (std::size_t)jarg2;
26307   {
26308     try {
26309       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
26310     } catch (std::out_of_range& e) {
26311       {
26312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26313       };
26314     } catch (std::exception& e) {
26315       {
26316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26317       };
26318     } catch (...) {
26319       {
26320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26321       };
26322     }
26323   }
26324   jresult = result;
26325   return jresult;
26326 }
26327
26328
26329 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
26330   int jresult ;
26331   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26332   std::size_t arg2 ;
26333   Dali::PointState::Type result;
26334
26335   arg1 = (Dali::TouchData *)jarg1;
26336   arg2 = (std::size_t)jarg2;
26337   {
26338     try {
26339       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
26340     } catch (std::out_of_range& e) {
26341       {
26342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26343       };
26344     } catch (std::exception& e) {
26345       {
26346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26347       };
26348     } catch (...) {
26349       {
26350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26351       };
26352     }
26353   }
26354   jresult = (int)result;
26355   return jresult;
26356 }
26357
26358
26359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
26360   void * jresult ;
26361   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26362   std::size_t arg2 ;
26363   Dali::Actor result;
26364
26365   arg1 = (Dali::TouchData *)jarg1;
26366   arg2 = (std::size_t)jarg2;
26367   {
26368     try {
26369       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
26370     } catch (std::out_of_range& e) {
26371       {
26372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26373       };
26374     } catch (std::exception& e) {
26375       {
26376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26377       };
26378     } catch (...) {
26379       {
26380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26381       };
26382     }
26383   }
26384   jresult = new Dali::Actor((const Dali::Actor &)result);
26385   return jresult;
26386 }
26387
26388
26389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
26390   void * jresult ;
26391   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26392   std::size_t arg2 ;
26393   Dali::Vector2 *result = 0 ;
26394
26395   arg1 = (Dali::TouchData *)jarg1;
26396   arg2 = (std::size_t)jarg2;
26397   {
26398     try {
26399       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
26400     } catch (std::out_of_range& e) {
26401       {
26402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26403       };
26404     } catch (std::exception& e) {
26405       {
26406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26407       };
26408     } catch (...) {
26409       {
26410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26411       };
26412     }
26413   }
26414   jresult = (void *)result;
26415   return jresult;
26416 }
26417
26418
26419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
26420   void * jresult ;
26421   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26422   std::size_t arg2 ;
26423   Dali::Vector2 *result = 0 ;
26424
26425   arg1 = (Dali::TouchData *)jarg1;
26426   arg2 = (std::size_t)jarg2;
26427   {
26428     try {
26429       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
26430     } catch (std::out_of_range& e) {
26431       {
26432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26433       };
26434     } catch (std::exception& e) {
26435       {
26436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26437       };
26438     } catch (...) {
26439       {
26440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26441       };
26442     }
26443   }
26444   jresult = (void *)result;
26445   return jresult;
26446 }
26447
26448
26449 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
26450   float jresult ;
26451   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26452   std::size_t arg2 ;
26453   float result;
26454
26455   arg1 = (Dali::TouchData *)jarg1;
26456   arg2 = (std::size_t)jarg2;
26457   {
26458     try {
26459       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
26460     } catch (std::out_of_range& e) {
26461       {
26462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26463       };
26464     } catch (std::exception& e) {
26465       {
26466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26467       };
26468     } catch (...) {
26469       {
26470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26471       };
26472     }
26473   }
26474   jresult = result;
26475   return jresult;
26476 }
26477
26478
26479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
26480   void * jresult ;
26481   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26482   std::size_t arg2 ;
26483   Dali::Vector2 *result = 0 ;
26484
26485   arg1 = (Dali::TouchData *)jarg1;
26486   arg2 = (std::size_t)jarg2;
26487   {
26488     try {
26489       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
26490     } catch (std::out_of_range& e) {
26491       {
26492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26493       };
26494     } catch (std::exception& e) {
26495       {
26496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26497       };
26498     } catch (...) {
26499       {
26500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26501       };
26502     }
26503   }
26504   jresult = (void *)result;
26505   return jresult;
26506 }
26507
26508
26509 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
26510   float jresult ;
26511   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26512   std::size_t arg2 ;
26513   float result;
26514
26515   arg1 = (Dali::TouchData *)jarg1;
26516   arg2 = (std::size_t)jarg2;
26517   {
26518     try {
26519       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
26520     } catch (std::out_of_range& e) {
26521       {
26522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26523       };
26524     } catch (std::exception& e) {
26525       {
26526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26527       };
26528     } catch (...) {
26529       {
26530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26531       };
26532     }
26533   }
26534   jresult = result;
26535   return jresult;
26536 }
26537
26538
26539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
26540   void * jresult ;
26541   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26542   std::size_t arg2 ;
26543   Dali::Degree result;
26544
26545   arg1 = (Dali::TouchData *)jarg1;
26546   arg2 = (std::size_t)jarg2;
26547   {
26548     try {
26549       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
26550     } catch (std::out_of_range& e) {
26551       {
26552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26553       };
26554     } catch (std::exception& e) {
26555       {
26556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26557       };
26558     } catch (...) {
26559       {
26560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26561       };
26562     }
26563   }
26564   jresult = new Dali::Degree((const Dali::Degree &)result);
26565   return jresult;
26566 }
26567
26568
26569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
26570   void * jresult ;
26571   Dali::GestureDetector *result = 0 ;
26572
26573   {
26574     try {
26575       result = (Dali::GestureDetector *)new Dali::GestureDetector();
26576     } catch (std::out_of_range& e) {
26577       {
26578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26579       };
26580     } catch (std::exception& e) {
26581       {
26582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26583       };
26584     } catch (...) {
26585       {
26586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26587       };
26588     }
26589   }
26590   jresult = (void *)result;
26591   return jresult;
26592 }
26593
26594
26595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
26596   void * jresult ;
26597   Dali::BaseHandle arg1 ;
26598   Dali::BaseHandle *argp1 ;
26599   Dali::GestureDetector result;
26600
26601   argp1 = (Dali::BaseHandle *)jarg1;
26602   if (!argp1) {
26603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26604     return 0;
26605   }
26606   arg1 = *argp1;
26607   {
26608     try {
26609       result = Dali::GestureDetector::DownCast(arg1);
26610     } catch (std::out_of_range& e) {
26611       {
26612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26613       };
26614     } catch (std::exception& e) {
26615       {
26616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26617       };
26618     } catch (...) {
26619       {
26620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26621       };
26622     }
26623   }
26624   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
26625   return jresult;
26626 }
26627
26628
26629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
26630   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26631
26632   arg1 = (Dali::GestureDetector *)jarg1;
26633   {
26634     try {
26635       delete arg1;
26636     } catch (std::out_of_range& e) {
26637       {
26638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26639       };
26640     } catch (std::exception& e) {
26641       {
26642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26643       };
26644     } catch (...) {
26645       {
26646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26647       };
26648     }
26649   }
26650 }
26651
26652
26653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
26654   void * jresult ;
26655   Dali::GestureDetector *arg1 = 0 ;
26656   Dali::GestureDetector *result = 0 ;
26657
26658   arg1 = (Dali::GestureDetector *)jarg1;
26659   if (!arg1) {
26660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26661     return 0;
26662   }
26663   {
26664     try {
26665       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
26666     } catch (std::out_of_range& e) {
26667       {
26668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26669       };
26670     } catch (std::exception& e) {
26671       {
26672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26673       };
26674     } catch (...) {
26675       {
26676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26677       };
26678     }
26679   }
26680   jresult = (void *)result;
26681   return jresult;
26682 }
26683
26684
26685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
26686   void * jresult ;
26687   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26688   Dali::GestureDetector *arg2 = 0 ;
26689   Dali::GestureDetector *result = 0 ;
26690
26691   arg1 = (Dali::GestureDetector *)jarg1;
26692   arg2 = (Dali::GestureDetector *)jarg2;
26693   if (!arg2) {
26694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26695     return 0;
26696   }
26697   {
26698     try {
26699       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
26700     } catch (std::out_of_range& e) {
26701       {
26702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26703       };
26704     } catch (std::exception& e) {
26705       {
26706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26707       };
26708     } catch (...) {
26709       {
26710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26711       };
26712     }
26713   }
26714   jresult = (void *)result;
26715   return jresult;
26716 }
26717
26718
26719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
26720   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26721   Dali::Actor arg2 ;
26722   Dali::Actor *argp2 ;
26723
26724   arg1 = (Dali::GestureDetector *)jarg1;
26725   argp2 = (Dali::Actor *)jarg2;
26726   if (!argp2) {
26727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26728     return ;
26729   }
26730   arg2 = *argp2;
26731   {
26732     try {
26733       (arg1)->Attach(arg2);
26734     } catch (std::out_of_range& e) {
26735       {
26736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26737       };
26738     } catch (std::exception& e) {
26739       {
26740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26741       };
26742     } catch (...) {
26743       {
26744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26745       };
26746     }
26747   }
26748 }
26749
26750
26751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
26752   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26753   Dali::Actor arg2 ;
26754   Dali::Actor *argp2 ;
26755
26756   arg1 = (Dali::GestureDetector *)jarg1;
26757   argp2 = (Dali::Actor *)jarg2;
26758   if (!argp2) {
26759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26760     return ;
26761   }
26762   arg2 = *argp2;
26763   {
26764     try {
26765       (arg1)->Detach(arg2);
26766     } catch (std::out_of_range& e) {
26767       {
26768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26769       };
26770     } catch (std::exception& e) {
26771       {
26772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26773       };
26774     } catch (...) {
26775       {
26776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26777       };
26778     }
26779   }
26780 }
26781
26782
26783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
26784   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26785
26786   arg1 = (Dali::GestureDetector *)jarg1;
26787   {
26788     try {
26789       (arg1)->DetachAll();
26790     } catch (std::out_of_range& e) {
26791       {
26792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26793       };
26794     } catch (std::exception& e) {
26795       {
26796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26797       };
26798     } catch (...) {
26799       {
26800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26801       };
26802     }
26803   }
26804 }
26805
26806
26807 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
26808   unsigned long jresult ;
26809   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26810   size_t result;
26811
26812   arg1 = (Dali::GestureDetector *)jarg1;
26813   {
26814     try {
26815       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
26816     } catch (std::out_of_range& e) {
26817       {
26818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26819       };
26820     } catch (std::exception& e) {
26821       {
26822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26823       };
26824     } catch (...) {
26825       {
26826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26827       };
26828     }
26829   }
26830   jresult = (unsigned long)result;
26831   return jresult;
26832 }
26833
26834
26835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
26836   void * jresult ;
26837   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26838   size_t arg2 ;
26839   Dali::Actor result;
26840
26841   arg1 = (Dali::GestureDetector *)jarg1;
26842   arg2 = (size_t)jarg2;
26843   {
26844     try {
26845       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
26846     } catch (std::out_of_range& e) {
26847       {
26848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26849       };
26850     } catch (std::exception& e) {
26851       {
26852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26853       };
26854     } catch (...) {
26855       {
26856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26857       };
26858     }
26859   }
26860   jresult = new Dali::Actor((const Dali::Actor &)result);
26861   return jresult;
26862 }
26863
26864
26865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
26866   void * jresult ;
26867   Dali::Gesture *arg1 = 0 ;
26868   Dali::Gesture *result = 0 ;
26869
26870   arg1 = (Dali::Gesture *)jarg1;
26871   if (!arg1) {
26872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26873     return 0;
26874   }
26875   {
26876     try {
26877       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
26878     } catch (std::out_of_range& e) {
26879       {
26880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26881       };
26882     } catch (std::exception& e) {
26883       {
26884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26885       };
26886     } catch (...) {
26887       {
26888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26889       };
26890     }
26891   }
26892   jresult = (void *)result;
26893   return jresult;
26894 }
26895
26896
26897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
26898   void * jresult ;
26899   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26900   Dali::Gesture *arg2 = 0 ;
26901   Dali::Gesture *result = 0 ;
26902
26903   arg1 = (Dali::Gesture *)jarg1;
26904   arg2 = (Dali::Gesture *)jarg2;
26905   if (!arg2) {
26906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26907     return 0;
26908   }
26909   {
26910     try {
26911       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
26912     } catch (std::out_of_range& e) {
26913       {
26914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26915       };
26916     } catch (std::exception& e) {
26917       {
26918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26919       };
26920     } catch (...) {
26921       {
26922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26923       };
26924     }
26925   }
26926   jresult = (void *)result;
26927   return jresult;
26928 }
26929
26930
26931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
26932   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26933
26934   arg1 = (Dali::Gesture *)jarg1;
26935   {
26936     try {
26937       delete arg1;
26938     } catch (std::out_of_range& e) {
26939       {
26940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26941       };
26942     } catch (std::exception& e) {
26943       {
26944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26945       };
26946     } catch (...) {
26947       {
26948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26949       };
26950     }
26951   }
26952 }
26953
26954
26955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
26956   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26957   Dali::Gesture::Type arg2 ;
26958
26959   arg1 = (Dali::Gesture *)jarg1;
26960   arg2 = (Dali::Gesture::Type)jarg2;
26961   if (arg1) (arg1)->type = arg2;
26962 }
26963
26964
26965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
26966   int jresult ;
26967   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26968   Dali::Gesture::Type result;
26969
26970   arg1 = (Dali::Gesture *)jarg1;
26971   result = (Dali::Gesture::Type) ((arg1)->type);
26972   jresult = (int)result;
26973   return jresult;
26974 }
26975
26976
26977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
26978   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26979   Dali::Gesture::State arg2 ;
26980
26981   arg1 = (Dali::Gesture *)jarg1;
26982   arg2 = (Dali::Gesture::State)jarg2;
26983   if (arg1) (arg1)->state = arg2;
26984 }
26985
26986
26987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
26988   int jresult ;
26989   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26990   Dali::Gesture::State result;
26991
26992   arg1 = (Dali::Gesture *)jarg1;
26993   result = (Dali::Gesture::State) ((arg1)->state);
26994   jresult = (int)result;
26995   return jresult;
26996 }
26997
26998
26999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
27000   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27001   unsigned int arg2 ;
27002
27003   arg1 = (Dali::Gesture *)jarg1;
27004   arg2 = (unsigned int)jarg2;
27005   if (arg1) (arg1)->time = arg2;
27006 }
27007
27008
27009 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
27010   unsigned int jresult ;
27011   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27012   unsigned int result;
27013
27014   arg1 = (Dali::Gesture *)jarg1;
27015   result = (unsigned int) ((arg1)->time);
27016   jresult = result;
27017   return jresult;
27018 }
27019
27020
27021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
27022   void * jresult ;
27023   Dali::HoverEvent *result = 0 ;
27024
27025   {
27026     try {
27027       result = (Dali::HoverEvent *)new Dali::HoverEvent();
27028     } catch (std::out_of_range& e) {
27029       {
27030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27031       };
27032     } catch (std::exception& e) {
27033       {
27034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27035       };
27036     } catch (...) {
27037       {
27038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27039       };
27040     }
27041   }
27042   jresult = (void *)result;
27043   return jresult;
27044 }
27045
27046
27047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
27048   void * jresult ;
27049   unsigned long arg1 ;
27050   Dali::HoverEvent *result = 0 ;
27051
27052   arg1 = (unsigned long)jarg1;
27053   {
27054     try {
27055       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
27056     } catch (std::out_of_range& e) {
27057       {
27058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27059       };
27060     } catch (std::exception& e) {
27061       {
27062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27063       };
27064     } catch (...) {
27065       {
27066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27067       };
27068     }
27069   }
27070   jresult = (void *)result;
27071   return jresult;
27072 }
27073
27074
27075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
27076   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27077
27078   arg1 = (Dali::HoverEvent *)jarg1;
27079   {
27080     try {
27081       delete arg1;
27082     } catch (std::out_of_range& e) {
27083       {
27084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27085       };
27086     } catch (std::exception& e) {
27087       {
27088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27089       };
27090     } catch (...) {
27091       {
27092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27093       };
27094     }
27095   }
27096 }
27097
27098
27099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
27100   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27101   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
27102
27103   arg1 = (Dali::HoverEvent *)jarg1;
27104   arg2 = (Dali::TouchPointContainer *)jarg2;
27105   if (arg1) (arg1)->points = *arg2;
27106 }
27107
27108
27109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
27110   void * jresult ;
27111   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27112   Dali::TouchPointContainer *result = 0 ;
27113
27114   arg1 = (Dali::HoverEvent *)jarg1;
27115   result = (Dali::TouchPointContainer *)& ((arg1)->points);
27116   jresult = (void *)result;
27117   return jresult;
27118 }
27119
27120
27121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
27122   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27123   unsigned long arg2 ;
27124
27125   arg1 = (Dali::HoverEvent *)jarg1;
27126   arg2 = (unsigned long)jarg2;
27127   if (arg1) (arg1)->time = arg2;
27128 }
27129
27130
27131 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
27132   unsigned long jresult ;
27133   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27134   unsigned long result;
27135
27136   arg1 = (Dali::HoverEvent *)jarg1;
27137   result = (unsigned long) ((arg1)->time);
27138   jresult = (unsigned long)result;
27139   return jresult;
27140 }
27141
27142
27143 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
27144   unsigned int jresult ;
27145   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27146   unsigned int result;
27147
27148   arg1 = (Dali::HoverEvent *)jarg1;
27149   {
27150     try {
27151       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
27152     } catch (std::out_of_range& e) {
27153       {
27154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27155       };
27156     } catch (std::exception& e) {
27157       {
27158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27159       };
27160     } catch (...) {
27161       {
27162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27163       };
27164     }
27165   }
27166   jresult = result;
27167   return jresult;
27168 }
27169
27170
27171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
27172   void * jresult ;
27173   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27174   unsigned int arg2 ;
27175   Dali::TouchPoint *result = 0 ;
27176
27177   arg1 = (Dali::HoverEvent *)jarg1;
27178   arg2 = (unsigned int)jarg2;
27179   {
27180     try {
27181       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
27182     } catch (std::out_of_range& e) {
27183       {
27184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27185       };
27186     } catch (std::exception& e) {
27187       {
27188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27189       };
27190     } catch (...) {
27191       {
27192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27193       };
27194     }
27195   }
27196   jresult = (void *)result;
27197   return jresult;
27198 }
27199
27200
27201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
27202   void * jresult ;
27203   Dali::KeyEvent *result = 0 ;
27204
27205   {
27206     try {
27207       result = (Dali::KeyEvent *)new Dali::KeyEvent();
27208     } catch (std::out_of_range& e) {
27209       {
27210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27211       };
27212     } catch (std::exception& e) {
27213       {
27214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27215       };
27216     } catch (...) {
27217       {
27218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27219       };
27220     }
27221   }
27222   jresult = (void *)result;
27223   return jresult;
27224 }
27225
27226
27227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
27228   void * jresult ;
27229   std::string *arg1 = 0 ;
27230   std::string *arg2 = 0 ;
27231   int arg3 ;
27232   int arg4 ;
27233   unsigned long arg5 ;
27234   Dali::KeyEvent::State *arg6 = 0 ;
27235   Dali::KeyEvent::State temp6 ;
27236   Dali::KeyEvent *result = 0 ;
27237
27238   if (!jarg1) {
27239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27240     return 0;
27241   }
27242   std::string arg1_str(jarg1);
27243   arg1 = &arg1_str;
27244   if (!jarg2) {
27245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27246     return 0;
27247   }
27248   std::string arg2_str(jarg2);
27249   arg2 = &arg2_str;
27250   arg3 = (int)jarg3;
27251   arg4 = (int)jarg4;
27252   arg5 = (unsigned long)jarg5;
27253   temp6 = (Dali::KeyEvent::State)jarg6;
27254   arg6 = &temp6;
27255   {
27256     try {
27257       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
27258     } catch (std::out_of_range& e) {
27259       {
27260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27261       };
27262     } catch (std::exception& e) {
27263       {
27264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27265       };
27266     } catch (...) {
27267       {
27268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27269       };
27270     }
27271   }
27272   jresult = (void *)result;
27273
27274   //argout typemap for const std::string&
27275
27276
27277   //argout typemap for const std::string&
27278
27279   return jresult;
27280 }
27281
27282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
27283   void * jresult ;
27284   Dali::KeyEvent *arg1 = 0 ;
27285   Dali::KeyEvent *result = 0 ;
27286
27287   arg1 = (Dali::KeyEvent *)jarg1;
27288   if (!arg1) {
27289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27290     return 0;
27291   }
27292   {
27293     try {
27294       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
27295     } catch (std::out_of_range& e) {
27296       {
27297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27298       };
27299     } catch (std::exception& e) {
27300       {
27301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27302       };
27303     } catch (...) {
27304       {
27305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27306       };
27307     }
27308   }
27309   jresult = (void *)result;
27310   return jresult;
27311 }
27312
27313
27314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
27315   void * jresult ;
27316   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27317   Dali::KeyEvent *arg2 = 0 ;
27318   Dali::KeyEvent *result = 0 ;
27319
27320   arg1 = (Dali::KeyEvent *)jarg1;
27321   arg2 = (Dali::KeyEvent *)jarg2;
27322   if (!arg2) {
27323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27324     return 0;
27325   }
27326   {
27327     try {
27328       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
27329     } catch (std::out_of_range& e) {
27330       {
27331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27332       };
27333     } catch (std::exception& e) {
27334       {
27335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27336       };
27337     } catch (...) {
27338       {
27339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27340       };
27341     }
27342   }
27343   jresult = (void *)result;
27344   return jresult;
27345 }
27346
27347
27348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
27349   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27350
27351   arg1 = (Dali::KeyEvent *)jarg1;
27352   {
27353     try {
27354       delete arg1;
27355     } catch (std::out_of_range& e) {
27356       {
27357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27358       };
27359     } catch (std::exception& e) {
27360       {
27361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27362       };
27363     } catch (...) {
27364       {
27365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27366       };
27367     }
27368   }
27369 }
27370
27371
27372 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
27373   unsigned int jresult ;
27374   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27375   bool result;
27376
27377   arg1 = (Dali::KeyEvent *)jarg1;
27378   {
27379     try {
27380       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
27381     } catch (std::out_of_range& e) {
27382       {
27383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27384       };
27385     } catch (std::exception& e) {
27386       {
27387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27388       };
27389     } catch (...) {
27390       {
27391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27392       };
27393     }
27394   }
27395   jresult = result;
27396   return jresult;
27397 }
27398
27399
27400 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
27401   unsigned int jresult ;
27402   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27403   bool result;
27404
27405   arg1 = (Dali::KeyEvent *)jarg1;
27406   {
27407     try {
27408       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
27409     } catch (std::out_of_range& e) {
27410       {
27411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27412       };
27413     } catch (std::exception& e) {
27414       {
27415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27416       };
27417     } catch (...) {
27418       {
27419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27420       };
27421     }
27422   }
27423   jresult = result;
27424   return jresult;
27425 }
27426
27427
27428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
27429   unsigned int jresult ;
27430   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27431   bool result;
27432
27433   arg1 = (Dali::KeyEvent *)jarg1;
27434   {
27435     try {
27436       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
27437     } catch (std::out_of_range& e) {
27438       {
27439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27440       };
27441     } catch (std::exception& e) {
27442       {
27443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27444       };
27445     } catch (...) {
27446       {
27447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27448       };
27449     }
27450   }
27451   jresult = result;
27452   return jresult;
27453 }
27454
27455
27456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
27457   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27458   std::string *arg2 = 0 ;
27459
27460   arg1 = (Dali::KeyEvent *)jarg1;
27461   if (!jarg2) {
27462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27463     return ;
27464   }
27465   std::string arg2_str(jarg2);
27466   arg2 = &arg2_str;
27467   if (arg1) (arg1)->keyPressedName = *arg2;
27468
27469   //argout typemap for const std::string&
27470
27471 }
27472
27473
27474 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
27475   char * jresult ;
27476   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27477   std::string *result = 0 ;
27478
27479   arg1 = (Dali::KeyEvent *)jarg1;
27480   result = (std::string *) & ((arg1)->keyPressedName);
27481   jresult = SWIG_csharp_string_callback(result->c_str());
27482   return jresult;
27483 }
27484
27485
27486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
27487   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27488   std::string *arg2 = 0 ;
27489
27490   arg1 = (Dali::KeyEvent *)jarg1;
27491   if (!jarg2) {
27492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27493     return ;
27494   }
27495   std::string arg2_str(jarg2);
27496   arg2 = &arg2_str;
27497   if (arg1) (arg1)->keyPressed = *arg2;
27498
27499   //argout typemap for const std::string&
27500
27501 }
27502
27503
27504 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
27505   char * jresult ;
27506   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27507   std::string *result = 0 ;
27508
27509   arg1 = (Dali::KeyEvent *)jarg1;
27510   result = (std::string *) & ((arg1)->keyPressed);
27511   jresult = SWIG_csharp_string_callback(result->c_str());
27512   return jresult;
27513 }
27514
27515
27516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
27517   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27518   int arg2 ;
27519
27520   arg1 = (Dali::KeyEvent *)jarg1;
27521   arg2 = (int)jarg2;
27522   if (arg1) (arg1)->keyCode = arg2;
27523 }
27524
27525
27526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
27527   int jresult ;
27528   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27529   int result;
27530
27531   arg1 = (Dali::KeyEvent *)jarg1;
27532   result = (int) ((arg1)->keyCode);
27533   jresult = result;
27534   return jresult;
27535 }
27536
27537
27538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
27539   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27540   int arg2 ;
27541
27542   arg1 = (Dali::KeyEvent *)jarg1;
27543   arg2 = (int)jarg2;
27544   if (arg1) (arg1)->keyModifier = arg2;
27545 }
27546
27547
27548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
27549   int jresult ;
27550   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27551   int result;
27552
27553   arg1 = (Dali::KeyEvent *)jarg1;
27554   result = (int) ((arg1)->keyModifier);
27555   jresult = result;
27556   return jresult;
27557 }
27558
27559
27560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
27561   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27562   unsigned long arg2 ;
27563
27564   arg1 = (Dali::KeyEvent *)jarg1;
27565   arg2 = (unsigned long)jarg2;
27566   if (arg1) (arg1)->time = arg2;
27567 }
27568
27569
27570 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
27571   unsigned long jresult ;
27572   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27573   unsigned long result;
27574
27575   arg1 = (Dali::KeyEvent *)jarg1;
27576   result = (unsigned long) ((arg1)->time);
27577   jresult = (unsigned long)result;
27578   return jresult;
27579 }
27580
27581
27582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
27583   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27584   Dali::KeyEvent::State arg2 ;
27585
27586   arg1 = (Dali::KeyEvent *)jarg1;
27587   arg2 = (Dali::KeyEvent::State)jarg2;
27588   if (arg1) (arg1)->state = arg2;
27589 }
27590
27591
27592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
27593   int jresult ;
27594   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27595   Dali::KeyEvent::State result;
27596
27597   arg1 = (Dali::KeyEvent *)jarg1;
27598   result = (Dali::KeyEvent::State) ((arg1)->state);
27599   jresult = (int)result;
27600   return jresult;
27601 }
27602
27603
27604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
27605   void * jresult ;
27606   Dali::LongPressGestureDetector *result = 0 ;
27607
27608   {
27609     try {
27610       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
27611     } catch (std::out_of_range& e) {
27612       {
27613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27614       };
27615     } catch (std::exception& e) {
27616       {
27617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27618       };
27619     } catch (...) {
27620       {
27621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27622       };
27623     }
27624   }
27625   jresult = (void *)result;
27626   return jresult;
27627 }
27628
27629
27630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
27631   void * jresult ;
27632   Dali::LongPressGestureDetector result;
27633
27634   {
27635     try {
27636       result = Dali::LongPressGestureDetector::New();
27637     } catch (std::out_of_range& e) {
27638       {
27639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27640       };
27641     } catch (std::exception& e) {
27642       {
27643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27644       };
27645     } catch (...) {
27646       {
27647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27648       };
27649     }
27650   }
27651   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27652   return jresult;
27653 }
27654
27655
27656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
27657   void * jresult ;
27658   unsigned int arg1 ;
27659   Dali::LongPressGestureDetector result;
27660
27661   arg1 = (unsigned int)jarg1;
27662   {
27663     try {
27664       result = Dali::LongPressGestureDetector::New(arg1);
27665     } catch (std::out_of_range& e) {
27666       {
27667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27668       };
27669     } catch (std::exception& e) {
27670       {
27671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27672       };
27673     } catch (...) {
27674       {
27675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27676       };
27677     }
27678   }
27679   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27680   return jresult;
27681 }
27682
27683
27684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
27685   void * jresult ;
27686   unsigned int arg1 ;
27687   unsigned int arg2 ;
27688   Dali::LongPressGestureDetector result;
27689
27690   arg1 = (unsigned int)jarg1;
27691   arg2 = (unsigned int)jarg2;
27692   {
27693     try {
27694       result = Dali::LongPressGestureDetector::New(arg1,arg2);
27695     } catch (std::out_of_range& e) {
27696       {
27697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27698       };
27699     } catch (std::exception& e) {
27700       {
27701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27702       };
27703     } catch (...) {
27704       {
27705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27706       };
27707     }
27708   }
27709   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27710   return jresult;
27711 }
27712
27713
27714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
27715   void * jresult ;
27716   Dali::BaseHandle arg1 ;
27717   Dali::BaseHandle *argp1 ;
27718   Dali::LongPressGestureDetector result;
27719
27720   argp1 = (Dali::BaseHandle *)jarg1;
27721   if (!argp1) {
27722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27723     return 0;
27724   }
27725   arg1 = *argp1;
27726   {
27727     try {
27728       result = Dali::LongPressGestureDetector::DownCast(arg1);
27729     } catch (std::out_of_range& e) {
27730       {
27731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27732       };
27733     } catch (std::exception& e) {
27734       {
27735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27736       };
27737     } catch (...) {
27738       {
27739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27740       };
27741     }
27742   }
27743   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27744   return jresult;
27745 }
27746
27747
27748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
27749   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27750
27751   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27752   {
27753     try {
27754       delete arg1;
27755     } catch (std::out_of_range& e) {
27756       {
27757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27758       };
27759     } catch (std::exception& e) {
27760       {
27761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27762       };
27763     } catch (...) {
27764       {
27765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27766       };
27767     }
27768   }
27769 }
27770
27771
27772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
27773   void * jresult ;
27774   Dali::LongPressGestureDetector *arg1 = 0 ;
27775   Dali::LongPressGestureDetector *result = 0 ;
27776
27777   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27778   if (!arg1) {
27779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27780     return 0;
27781   }
27782   {
27783     try {
27784       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
27785     } catch (std::out_of_range& e) {
27786       {
27787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27788       };
27789     } catch (std::exception& e) {
27790       {
27791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27792       };
27793     } catch (...) {
27794       {
27795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27796       };
27797     }
27798   }
27799   jresult = (void *)result;
27800   return jresult;
27801 }
27802
27803
27804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
27805   void * jresult ;
27806   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27807   Dali::LongPressGestureDetector *arg2 = 0 ;
27808   Dali::LongPressGestureDetector *result = 0 ;
27809
27810   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27811   arg2 = (Dali::LongPressGestureDetector *)jarg2;
27812   if (!arg2) {
27813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27814     return 0;
27815   }
27816   {
27817     try {
27818       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
27819     } catch (std::out_of_range& e) {
27820       {
27821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27822       };
27823     } catch (std::exception& e) {
27824       {
27825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27826       };
27827     } catch (...) {
27828       {
27829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27830       };
27831     }
27832   }
27833   jresult = (void *)result;
27834   return jresult;
27835 }
27836
27837
27838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
27839   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27840   unsigned int arg2 ;
27841
27842   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27843   arg2 = (unsigned int)jarg2;
27844   {
27845     try {
27846       (arg1)->SetTouchesRequired(arg2);
27847     } catch (std::out_of_range& e) {
27848       {
27849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27850       };
27851     } catch (std::exception& e) {
27852       {
27853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27854       };
27855     } catch (...) {
27856       {
27857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27858       };
27859     }
27860   }
27861 }
27862
27863
27864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
27865   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27866   unsigned int arg2 ;
27867   unsigned int arg3 ;
27868
27869   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27870   arg2 = (unsigned int)jarg2;
27871   arg3 = (unsigned int)jarg3;
27872   {
27873     try {
27874       (arg1)->SetTouchesRequired(arg2,arg3);
27875     } catch (std::out_of_range& e) {
27876       {
27877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27878       };
27879     } catch (std::exception& e) {
27880       {
27881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27882       };
27883     } catch (...) {
27884       {
27885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27886       };
27887     }
27888   }
27889 }
27890
27891
27892 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
27893   unsigned int jresult ;
27894   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27895   unsigned int result;
27896
27897   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27898   {
27899     try {
27900       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
27901     } catch (std::out_of_range& e) {
27902       {
27903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27904       };
27905     } catch (std::exception& e) {
27906       {
27907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27908       };
27909     } catch (...) {
27910       {
27911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27912       };
27913     }
27914   }
27915   jresult = result;
27916   return jresult;
27917 }
27918
27919
27920 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
27921   unsigned int jresult ;
27922   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27923   unsigned int result;
27924
27925   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27926   {
27927     try {
27928       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
27929     } catch (std::out_of_range& e) {
27930       {
27931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27932       };
27933     } catch (std::exception& e) {
27934       {
27935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27936       };
27937     } catch (...) {
27938       {
27939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27940       };
27941     }
27942   }
27943   jresult = result;
27944   return jresult;
27945 }
27946
27947
27948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
27949   void * jresult ;
27950   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27951   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
27952
27953   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27954   {
27955     try {
27956       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
27957     } catch (std::out_of_range& e) {
27958       {
27959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27960       };
27961     } catch (std::exception& e) {
27962       {
27963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27964       };
27965     } catch (...) {
27966       {
27967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27968       };
27969     }
27970   }
27971   jresult = (void *)result;
27972   return jresult;
27973 }
27974
27975
27976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
27977   void * jresult ;
27978   Dali::Gesture::State arg1 ;
27979   Dali::LongPressGesture *result = 0 ;
27980
27981   arg1 = (Dali::Gesture::State)jarg1;
27982   {
27983     try {
27984       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
27985     } catch (std::out_of_range& e) {
27986       {
27987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27988       };
27989     } catch (std::exception& e) {
27990       {
27991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27992       };
27993     } catch (...) {
27994       {
27995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27996       };
27997     }
27998   }
27999   jresult = (void *)result;
28000   return jresult;
28001 }
28002
28003
28004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
28005   void * jresult ;
28006   Dali::LongPressGesture *arg1 = 0 ;
28007   Dali::LongPressGesture *result = 0 ;
28008
28009   arg1 = (Dali::LongPressGesture *)jarg1;
28010   if (!arg1) {
28011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
28012     return 0;
28013   }
28014   {
28015     try {
28016       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
28017     } catch (std::out_of_range& e) {
28018       {
28019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28020       };
28021     } catch (std::exception& e) {
28022       {
28023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28024       };
28025     } catch (...) {
28026       {
28027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28028       };
28029     }
28030   }
28031   jresult = (void *)result;
28032   return jresult;
28033 }
28034
28035
28036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
28037   void * jresult ;
28038   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28039   Dali::LongPressGesture *arg2 = 0 ;
28040   Dali::LongPressGesture *result = 0 ;
28041
28042   arg1 = (Dali::LongPressGesture *)jarg1;
28043   arg2 = (Dali::LongPressGesture *)jarg2;
28044   if (!arg2) {
28045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
28046     return 0;
28047   }
28048   {
28049     try {
28050       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
28051     } catch (std::out_of_range& e) {
28052       {
28053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28054       };
28055     } catch (std::exception& e) {
28056       {
28057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28058       };
28059     } catch (...) {
28060       {
28061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28062       };
28063     }
28064   }
28065   jresult = (void *)result;
28066   return jresult;
28067 }
28068
28069
28070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
28071   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28072
28073   arg1 = (Dali::LongPressGesture *)jarg1;
28074   {
28075     try {
28076       delete arg1;
28077     } catch (std::out_of_range& e) {
28078       {
28079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28080       };
28081     } catch (std::exception& e) {
28082       {
28083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28084       };
28085     } catch (...) {
28086       {
28087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28088       };
28089     }
28090   }
28091 }
28092
28093
28094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
28095   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28096   unsigned int arg2 ;
28097
28098   arg1 = (Dali::LongPressGesture *)jarg1;
28099   arg2 = (unsigned int)jarg2;
28100   if (arg1) (arg1)->numberOfTouches = arg2;
28101 }
28102
28103
28104 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
28105   unsigned int jresult ;
28106   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28107   unsigned int result;
28108
28109   arg1 = (Dali::LongPressGesture *)jarg1;
28110   result = (unsigned int) ((arg1)->numberOfTouches);
28111   jresult = result;
28112   return jresult;
28113 }
28114
28115
28116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
28117   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28118   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28119
28120   arg1 = (Dali::LongPressGesture *)jarg1;
28121   arg2 = (Dali::Vector2 *)jarg2;
28122   if (arg1) (arg1)->screenPoint = *arg2;
28123 }
28124
28125
28126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
28127   void * jresult ;
28128   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28129   Dali::Vector2 *result = 0 ;
28130
28131   arg1 = (Dali::LongPressGesture *)jarg1;
28132   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
28133   jresult = (void *)result;
28134   return jresult;
28135 }
28136
28137
28138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
28139   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28140   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28141
28142   arg1 = (Dali::LongPressGesture *)jarg1;
28143   arg2 = (Dali::Vector2 *)jarg2;
28144   if (arg1) (arg1)->localPoint = *arg2;
28145 }
28146
28147
28148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
28149   void * jresult ;
28150   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28151   Dali::Vector2 *result = 0 ;
28152
28153   arg1 = (Dali::LongPressGesture *)jarg1;
28154   result = (Dali::Vector2 *)& ((arg1)->localPoint);
28155   jresult = (void *)result;
28156   return jresult;
28157 }
28158
28159
28160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
28161   void * jresult ;
28162   Dali::WheelEvent *result = 0 ;
28163
28164   {
28165     try {
28166       result = (Dali::WheelEvent *)new Dali::WheelEvent();
28167     } catch (std::out_of_range& e) {
28168       {
28169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28170       };
28171     } catch (std::exception& e) {
28172       {
28173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28174       };
28175     } catch (...) {
28176       {
28177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28178       };
28179     }
28180   }
28181   jresult = (void *)result;
28182   return jresult;
28183 }
28184
28185
28186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
28187   void * jresult ;
28188   Dali::WheelEvent::Type arg1 ;
28189   int arg2 ;
28190   unsigned int arg3 ;
28191   Dali::Vector2 arg4 ;
28192   int arg5 ;
28193   unsigned int arg6 ;
28194   Dali::Vector2 *argp4 ;
28195   Dali::WheelEvent *result = 0 ;
28196
28197   arg1 = (Dali::WheelEvent::Type)jarg1;
28198   arg2 = (int)jarg2;
28199   arg3 = (unsigned int)jarg3;
28200   argp4 = (Dali::Vector2 *)jarg4;
28201   if (!argp4) {
28202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28203     return 0;
28204   }
28205   arg4 = *argp4;
28206   arg5 = (int)jarg5;
28207   arg6 = (unsigned int)jarg6;
28208   {
28209     try {
28210       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
28211     } catch (std::out_of_range& e) {
28212       {
28213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28214       };
28215     } catch (std::exception& e) {
28216       {
28217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28218       };
28219     } catch (...) {
28220       {
28221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28222       };
28223     }
28224   }
28225   jresult = (void *)result;
28226   return jresult;
28227 }
28228
28229
28230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
28231   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28232
28233   arg1 = (Dali::WheelEvent *)jarg1;
28234   {
28235     try {
28236       delete arg1;
28237     } catch (std::out_of_range& e) {
28238       {
28239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28240       };
28241     } catch (std::exception& e) {
28242       {
28243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28244       };
28245     } catch (...) {
28246       {
28247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28248       };
28249     }
28250   }
28251 }
28252
28253
28254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
28255   unsigned int jresult ;
28256   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28257   bool result;
28258
28259   arg1 = (Dali::WheelEvent *)jarg1;
28260   {
28261     try {
28262       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
28263     } catch (std::out_of_range& e) {
28264       {
28265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28266       };
28267     } catch (std::exception& e) {
28268       {
28269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28270       };
28271     } catch (...) {
28272       {
28273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28274       };
28275     }
28276   }
28277   jresult = result;
28278   return jresult;
28279 }
28280
28281
28282 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
28283   unsigned int jresult ;
28284   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28285   bool result;
28286
28287   arg1 = (Dali::WheelEvent *)jarg1;
28288   {
28289     try {
28290       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
28291     } catch (std::out_of_range& e) {
28292       {
28293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28294       };
28295     } catch (std::exception& e) {
28296       {
28297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28298       };
28299     } catch (...) {
28300       {
28301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28302       };
28303     }
28304   }
28305   jresult = result;
28306   return jresult;
28307 }
28308
28309
28310 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
28311   unsigned int jresult ;
28312   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28313   bool result;
28314
28315   arg1 = (Dali::WheelEvent *)jarg1;
28316   {
28317     try {
28318       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
28319     } catch (std::out_of_range& e) {
28320       {
28321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28322       };
28323     } catch (std::exception& e) {
28324       {
28325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28326       };
28327     } catch (...) {
28328       {
28329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28330       };
28331     }
28332   }
28333   jresult = result;
28334   return jresult;
28335 }
28336
28337
28338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
28339   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28340   Dali::WheelEvent::Type arg2 ;
28341
28342   arg1 = (Dali::WheelEvent *)jarg1;
28343   arg2 = (Dali::WheelEvent::Type)jarg2;
28344   if (arg1) (arg1)->type = arg2;
28345 }
28346
28347
28348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
28349   int jresult ;
28350   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28351   Dali::WheelEvent::Type result;
28352
28353   arg1 = (Dali::WheelEvent *)jarg1;
28354   result = (Dali::WheelEvent::Type) ((arg1)->type);
28355   jresult = (int)result;
28356   return jresult;
28357 }
28358
28359
28360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
28361   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28362   int arg2 ;
28363
28364   arg1 = (Dali::WheelEvent *)jarg1;
28365   arg2 = (int)jarg2;
28366   if (arg1) (arg1)->direction = arg2;
28367 }
28368
28369
28370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
28371   int jresult ;
28372   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28373   int result;
28374
28375   arg1 = (Dali::WheelEvent *)jarg1;
28376   result = (int) ((arg1)->direction);
28377   jresult = result;
28378   return jresult;
28379 }
28380
28381
28382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
28383   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28384   unsigned int arg2 ;
28385
28386   arg1 = (Dali::WheelEvent *)jarg1;
28387   arg2 = (unsigned int)jarg2;
28388   if (arg1) (arg1)->modifiers = arg2;
28389 }
28390
28391
28392 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
28393   unsigned int jresult ;
28394   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28395   unsigned int result;
28396
28397   arg1 = (Dali::WheelEvent *)jarg1;
28398   result = (unsigned int) ((arg1)->modifiers);
28399   jresult = result;
28400   return jresult;
28401 }
28402
28403
28404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
28405   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28406   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28407
28408   arg1 = (Dali::WheelEvent *)jarg1;
28409   arg2 = (Dali::Vector2 *)jarg2;
28410   if (arg1) (arg1)->point = *arg2;
28411 }
28412
28413
28414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
28415   void * jresult ;
28416   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28417   Dali::Vector2 *result = 0 ;
28418
28419   arg1 = (Dali::WheelEvent *)jarg1;
28420   result = (Dali::Vector2 *)& ((arg1)->point);
28421   jresult = (void *)result;
28422   return jresult;
28423 }
28424
28425
28426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
28427   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28428   int arg2 ;
28429
28430   arg1 = (Dali::WheelEvent *)jarg1;
28431   arg2 = (int)jarg2;
28432   if (arg1) (arg1)->z = arg2;
28433 }
28434
28435
28436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
28437   int jresult ;
28438   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28439   int result;
28440
28441   arg1 = (Dali::WheelEvent *)jarg1;
28442   result = (int) ((arg1)->z);
28443   jresult = result;
28444   return jresult;
28445 }
28446
28447
28448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
28449   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28450   unsigned int arg2 ;
28451
28452   arg1 = (Dali::WheelEvent *)jarg1;
28453   arg2 = (unsigned int)jarg2;
28454   if (arg1) (arg1)->timeStamp = arg2;
28455 }
28456
28457
28458 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
28459   unsigned int jresult ;
28460   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28461   unsigned int result;
28462
28463   arg1 = (Dali::WheelEvent *)jarg1;
28464   result = (unsigned int) ((arg1)->timeStamp);
28465   jresult = result;
28466   return jresult;
28467 }
28468
28469 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
28470   char * jresult ;
28471   Dali::KeyEvent *arg1 = 0 ;
28472   std::string result;
28473
28474   arg1 = (Dali::KeyEvent *)jarg1;
28475   if (!arg1) {
28476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28477     return 0;
28478   }
28479   {
28480     try {
28481       result = Dali::DevelKeyEvent::GetDeviceName((Dali::KeyEvent const &)*arg1);
28482     } catch (std::out_of_range& e) {
28483       {
28484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28485       };
28486     } catch (std::exception& e) {
28487       {
28488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28489       };
28490     } catch (...) {
28491       {
28492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28493       };
28494     }
28495   }
28496   jresult = SWIG_csharp_string_callback((&result)->c_str());
28497   return jresult;
28498 }
28499
28500
28501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetDeviceName(void * jarg1, char * jarg2) {
28502   Dali::KeyEvent *arg1 = 0 ;
28503   std::string *arg2 = 0 ;
28504
28505   arg1 = (Dali::KeyEvent *)jarg1;
28506   if (!arg1) {
28507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent & type is null", 0);
28508     return ;
28509   }
28510   if (!jarg2) {
28511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
28512     return ;
28513   }
28514   std::string arg2_str(jarg2);
28515   arg2 = &arg2_str;
28516   {
28517     try {
28518       Dali::DevelKeyEvent::SetDeviceName(*arg1,(std::string const &)*arg2);
28519     } catch (std::out_of_range& e) {
28520       {
28521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28522       };
28523     } catch (std::exception& e) {
28524       {
28525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28526       };
28527     } catch (...) {
28528       {
28529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28530       };
28531     }
28532   }
28533
28534   //argout typemap for const std::string&
28535
28536 }
28537
28538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
28539   int jresult ;
28540   Dali::KeyEvent *arg1 = 0 ;
28541   Dali::DevelKeyEvent::DeviceClass::Type result;
28542
28543   arg1 = (Dali::KeyEvent *)jarg1;
28544   if (!arg1) {
28545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28546     return 0;
28547   }
28548   {
28549     try {
28550       result = (Dali::DevelKeyEvent::DeviceClass::Type)Dali::DevelKeyEvent::GetDeviceClass((Dali::KeyEvent const &)*arg1);
28551     } catch (std::out_of_range& e) {
28552       {
28553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28554       };
28555     } catch (std::exception& e) {
28556       {
28557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28558       };
28559     } catch (...) {
28560       {
28561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28562       };
28563     }
28564   }
28565   jresult = (int)result;
28566   return jresult;
28567 }
28568
28569
28570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetDeviceClass(void * jarg1, int jarg2) {
28571   Dali::KeyEvent *arg1 = 0 ;
28572   Dali::DevelKeyEvent::DeviceClass::Type *arg2 = 0 ;
28573   Dali::DevelKeyEvent::DeviceClass::Type temp2 ;
28574
28575   arg1 = (Dali::KeyEvent *)jarg1;
28576   if (!arg1) {
28577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent & type is null", 0);
28578     return ;
28579   }
28580   temp2 = (Dali::DevelKeyEvent::DeviceClass::Type)jarg2;
28581   arg2 = &temp2;
28582   {
28583     try {
28584       Dali::DevelKeyEvent::SetDeviceClass(*arg1,(enum Dali::DevelKeyEvent::DeviceClass::Type const &)*arg2);
28585     } catch (std::out_of_range& e) {
28586       {
28587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28588       };
28589     } catch (std::exception& e) {
28590       {
28591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28592       };
28593     } catch (...) {
28594       {
28595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28596       };
28597     }
28598   }
28599 }
28600
28601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
28602   int jresult ;
28603   int result;
28604
28605   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
28606   jresult = (int)result;
28607   return jresult;
28608 }
28609
28610
28611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
28612   int jresult ;
28613   int result;
28614
28615   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
28616   jresult = (int)result;
28617   return jresult;
28618 }
28619
28620
28621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
28622   int jresult ;
28623   int result;
28624
28625   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
28626   jresult = (int)result;
28627   return jresult;
28628 }
28629
28630
28631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
28632   int jresult ;
28633   int result;
28634
28635   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
28636   jresult = (int)result;
28637   return jresult;
28638 }
28639
28640
28641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
28642   int jresult ;
28643   int result;
28644
28645   result = (int)Dali::Actor::Property::ANCHOR_POINT;
28646   jresult = (int)result;
28647   return jresult;
28648 }
28649
28650
28651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
28652   int jresult ;
28653   int result;
28654
28655   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
28656   jresult = (int)result;
28657   return jresult;
28658 }
28659
28660
28661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
28662   int jresult ;
28663   int result;
28664
28665   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
28666   jresult = (int)result;
28667   return jresult;
28668 }
28669
28670
28671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
28672   int jresult ;
28673   int result;
28674
28675   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
28676   jresult = (int)result;
28677   return jresult;
28678 }
28679
28680
28681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
28682   int jresult ;
28683   int result;
28684
28685   result = (int)Dali::Actor::Property::SIZE;
28686   jresult = (int)result;
28687   return jresult;
28688 }
28689
28690
28691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
28692   int jresult ;
28693   int result;
28694
28695   result = (int)Dali::Actor::Property::SIZE_WIDTH;
28696   jresult = (int)result;
28697   return jresult;
28698 }
28699
28700
28701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
28702   int jresult ;
28703   int result;
28704
28705   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
28706   jresult = (int)result;
28707   return jresult;
28708 }
28709
28710
28711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
28712   int jresult ;
28713   int result;
28714
28715   result = (int)Dali::Actor::Property::SIZE_DEPTH;
28716   jresult = (int)result;
28717   return jresult;
28718 }
28719
28720
28721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
28722   int jresult ;
28723   int result;
28724
28725   result = (int)Dali::Actor::Property::POSITION;
28726   jresult = (int)result;
28727   return jresult;
28728 }
28729
28730
28731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
28732   int jresult ;
28733   int result;
28734
28735   result = (int)Dali::Actor::Property::POSITION_X;
28736   jresult = (int)result;
28737   return jresult;
28738 }
28739
28740
28741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
28742   int jresult ;
28743   int result;
28744
28745   result = (int)Dali::Actor::Property::POSITION_Y;
28746   jresult = (int)result;
28747   return jresult;
28748 }
28749
28750
28751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
28752   int jresult ;
28753   int result;
28754
28755   result = (int)Dali::Actor::Property::POSITION_Z;
28756   jresult = (int)result;
28757   return jresult;
28758 }
28759
28760
28761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
28762   int jresult ;
28763   int result;
28764
28765   result = (int)Dali::Actor::Property::WORLD_POSITION;
28766   jresult = (int)result;
28767   return jresult;
28768 }
28769
28770
28771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
28772   int jresult ;
28773   int result;
28774
28775   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
28776   jresult = (int)result;
28777   return jresult;
28778 }
28779
28780
28781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
28782   int jresult ;
28783   int result;
28784
28785   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
28786   jresult = (int)result;
28787   return jresult;
28788 }
28789
28790
28791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
28792   int jresult ;
28793   int result;
28794
28795   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
28796   jresult = (int)result;
28797   return jresult;
28798 }
28799
28800
28801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
28802   int jresult ;
28803   int result;
28804
28805   result = (int)Dali::Actor::Property::ORIENTATION;
28806   jresult = (int)result;
28807   return jresult;
28808 }
28809
28810
28811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
28812   int jresult ;
28813   int result;
28814
28815   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
28816   jresult = (int)result;
28817   return jresult;
28818 }
28819
28820
28821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
28822   int jresult ;
28823   int result;
28824
28825   result = (int)Dali::Actor::Property::SCALE;
28826   jresult = (int)result;
28827   return jresult;
28828 }
28829
28830
28831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
28832   int jresult ;
28833   int result;
28834
28835   result = (int)Dali::Actor::Property::SCALE_X;
28836   jresult = (int)result;
28837   return jresult;
28838 }
28839
28840
28841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
28842   int jresult ;
28843   int result;
28844
28845   result = (int)Dali::Actor::Property::SCALE_Y;
28846   jresult = (int)result;
28847   return jresult;
28848 }
28849
28850
28851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
28852   int jresult ;
28853   int result;
28854
28855   result = (int)Dali::Actor::Property::SCALE_Z;
28856   jresult = (int)result;
28857   return jresult;
28858 }
28859
28860
28861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
28862   int jresult ;
28863   int result;
28864
28865   result = (int)Dali::Actor::Property::WORLD_SCALE;
28866   jresult = (int)result;
28867   return jresult;
28868 }
28869
28870
28871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
28872   int jresult ;
28873   int result;
28874
28875   result = (int)Dali::Actor::Property::VISIBLE;
28876   jresult = (int)result;
28877   return jresult;
28878 }
28879
28880
28881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
28882   int jresult ;
28883   int result;
28884
28885   result = (int)Dali::Actor::Property::COLOR;
28886   jresult = (int)result;
28887   return jresult;
28888 }
28889
28890
28891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
28892   int jresult ;
28893   int result;
28894
28895   result = (int)Dali::Actor::Property::COLOR_RED;
28896   jresult = (int)result;
28897   return jresult;
28898 }
28899
28900
28901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
28902   int jresult ;
28903   int result;
28904
28905   result = (int)Dali::Actor::Property::COLOR_GREEN;
28906   jresult = (int)result;
28907   return jresult;
28908 }
28909
28910
28911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
28912   int jresult ;
28913   int result;
28914
28915   result = (int)Dali::Actor::Property::COLOR_BLUE;
28916   jresult = (int)result;
28917   return jresult;
28918 }
28919
28920
28921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
28922   int jresult ;
28923   int result;
28924
28925   result = (int)Dali::Actor::Property::COLOR_ALPHA;
28926   jresult = (int)result;
28927   return jresult;
28928 }
28929
28930
28931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
28932   int jresult ;
28933   int result;
28934
28935   result = (int)Dali::Actor::Property::WORLD_COLOR;
28936   jresult = (int)result;
28937   return jresult;
28938 }
28939
28940
28941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
28942   int jresult ;
28943   int result;
28944
28945   result = (int)Dali::Actor::Property::WORLD_MATRIX;
28946   jresult = (int)result;
28947   return jresult;
28948 }
28949
28950
28951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
28952   int jresult ;
28953   int result;
28954
28955   result = (int)Dali::Actor::Property::NAME;
28956   jresult = (int)result;
28957   return jresult;
28958 }
28959
28960
28961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
28962   int jresult ;
28963   int result;
28964
28965   result = (int)Dali::Actor::Property::SENSITIVE;
28966   jresult = (int)result;
28967   return jresult;
28968 }
28969
28970
28971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
28972   int jresult ;
28973   int result;
28974
28975   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
28976   jresult = (int)result;
28977   return jresult;
28978 }
28979
28980
28981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
28982   int jresult ;
28983   int result;
28984
28985   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
28986   jresult = (int)result;
28987   return jresult;
28988 }
28989
28990
28991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
28992   int jresult ;
28993   int result;
28994
28995   result = (int)Dali::Actor::Property::INHERIT_SCALE;
28996   jresult = (int)result;
28997   return jresult;
28998 }
28999
29000
29001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
29002   int jresult ;
29003   int result;
29004
29005   result = (int)Dali::Actor::Property::COLOR_MODE;
29006   jresult = (int)result;
29007   return jresult;
29008 }
29009
29010
29011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
29012   int jresult ;
29013   int result;
29014
29015   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
29016   jresult = (int)result;
29017   return jresult;
29018 }
29019
29020
29021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
29022   int jresult ;
29023   int result;
29024
29025   result = (int)Dali::Actor::Property::DRAW_MODE;
29026   jresult = (int)result;
29027   return jresult;
29028 }
29029
29030
29031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
29032   int jresult ;
29033   int result;
29034
29035   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
29036   jresult = (int)result;
29037   return jresult;
29038 }
29039
29040
29041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
29042   int jresult ;
29043   int result;
29044
29045   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
29046   jresult = (int)result;
29047   return jresult;
29048 }
29049
29050
29051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
29052   int jresult ;
29053   int result;
29054
29055   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
29056   jresult = (int)result;
29057   return jresult;
29058 }
29059
29060
29061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
29062   int jresult ;
29063   int result;
29064
29065   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
29066   jresult = (int)result;
29067   return jresult;
29068 }
29069
29070
29071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
29072   int jresult ;
29073   int result;
29074
29075   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
29076   jresult = (int)result;
29077   return jresult;
29078 }
29079
29080
29081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
29082   int jresult ;
29083   int result;
29084
29085   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
29086   jresult = (int)result;
29087   return jresult;
29088 }
29089
29090
29091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
29092   int jresult ;
29093   int result;
29094
29095   result = (int)Dali::Actor::Property::PADDING;
29096   jresult = (int)result;
29097   return jresult;
29098 }
29099
29100
29101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
29102   int jresult ;
29103   int result;
29104
29105   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
29106   jresult = (int)result;
29107   return jresult;
29108 }
29109
29110
29111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
29112   int jresult ;
29113   int result;
29114
29115   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
29116   jresult = (int)result;
29117   return jresult;
29118 }
29119
29120
29121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
29122   int jresult ;
29123   int result;
29124
29125   result = (int)Dali::Actor::Property::INHERIT_POSITION;
29126   jresult = (int)result;
29127   return jresult;
29128 }
29129
29130
29131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
29132   int jresult ;
29133   int result;
29134
29135   result = (int)Dali::Actor::Property::CLIPPING_MODE;
29136   jresult = (int)result;
29137   return jresult;
29138 }
29139
29140
29141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
29142   void * jresult ;
29143   Dali::Actor::Property *result = 0 ;
29144
29145   {
29146     try {
29147       result = (Dali::Actor::Property *)new Dali::Actor::Property();
29148     } catch (std::out_of_range& e) {
29149       {
29150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29151       };
29152     } catch (std::exception& e) {
29153       {
29154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29155       };
29156     } catch (...) {
29157       {
29158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29159       };
29160     }
29161   }
29162   jresult = (void *)result;
29163   return jresult;
29164 }
29165
29166
29167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
29168   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
29169
29170   arg1 = (Dali::Actor::Property *)jarg1;
29171   {
29172     try {
29173       delete arg1;
29174     } catch (std::out_of_range& e) {
29175       {
29176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29177       };
29178     } catch (std::exception& e) {
29179       {
29180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29181       };
29182     } catch (...) {
29183       {
29184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29185       };
29186     }
29187   }
29188 }
29189
29190
29191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
29192   void * jresult ;
29193   Dali::Actor *result = 0 ;
29194
29195   {
29196     try {
29197       result = (Dali::Actor *)new Dali::Actor();
29198     } catch (std::out_of_range& e) {
29199       {
29200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29201       };
29202     } catch (std::exception& e) {
29203       {
29204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29205       };
29206     } catch (...) {
29207       {
29208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29209       };
29210     }
29211   }
29212   jresult = (void *)result;
29213   return jresult;
29214 }
29215
29216
29217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
29218   void * jresult ;
29219   Dali::Actor result;
29220
29221   {
29222     try {
29223       result = Dali::Actor::New();
29224     } catch (std::out_of_range& e) {
29225       {
29226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29227       };
29228     } catch (std::exception& e) {
29229       {
29230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29231       };
29232     } catch (...) {
29233       {
29234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29235       };
29236     }
29237   }
29238   jresult = new Dali::Actor((const Dali::Actor &)result);
29239   return jresult;
29240 }
29241
29242
29243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
29244   void * jresult ;
29245   Dali::BaseHandle arg1 ;
29246   Dali::BaseHandle *argp1 ;
29247   Dali::Actor result;
29248
29249   argp1 = (Dali::BaseHandle *)jarg1;
29250   if (!argp1) {
29251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
29252     return 0;
29253   }
29254   arg1 = *argp1;
29255   {
29256     try {
29257       result = Dali::Actor::DownCast(arg1);
29258     } catch (std::out_of_range& e) {
29259       {
29260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29261       };
29262     } catch (std::exception& e) {
29263       {
29264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29265       };
29266     } catch (...) {
29267       {
29268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29269       };
29270     }
29271   }
29272   jresult = new Dali::Actor((const Dali::Actor &)result);
29273   return jresult;
29274 }
29275
29276
29277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
29278   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29279
29280   arg1 = (Dali::Actor *)jarg1;
29281   {
29282     try {
29283       delete arg1;
29284     } catch (std::out_of_range& e) {
29285       {
29286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29287       };
29288     } catch (std::exception& e) {
29289       {
29290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29291       };
29292     } catch (...) {
29293       {
29294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29295       };
29296     }
29297   }
29298 }
29299
29300
29301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
29302   void * jresult ;
29303   Dali::Actor *arg1 = 0 ;
29304   Dali::Actor *result = 0 ;
29305
29306   arg1 = (Dali::Actor *)jarg1;
29307   if (!arg1) {
29308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29309     return 0;
29310   }
29311   {
29312     try {
29313       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
29314     } catch (std::out_of_range& e) {
29315       {
29316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29317       };
29318     } catch (std::exception& e) {
29319       {
29320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29321       };
29322     } catch (...) {
29323       {
29324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29325       };
29326     }
29327   }
29328   jresult = (void *)result;
29329   return jresult;
29330 }
29331
29332
29333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
29334   void * jresult ;
29335   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29336   Dali::Actor *arg2 = 0 ;
29337   Dali::Actor *result = 0 ;
29338
29339   arg1 = (Dali::Actor *)jarg1;
29340   arg2 = (Dali::Actor *)jarg2;
29341   if (!arg2) {
29342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29343     return 0;
29344   }
29345   {
29346     try {
29347       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
29348     } catch (std::out_of_range& e) {
29349       {
29350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29351       };
29352     } catch (std::exception& e) {
29353       {
29354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29355       };
29356     } catch (...) {
29357       {
29358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29359       };
29360     }
29361   }
29362   jresult = (void *)result;
29363   return jresult;
29364 }
29365
29366
29367 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
29368   char * jresult ;
29369   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29370   std::string *result = 0 ;
29371
29372   arg1 = (Dali::Actor *)jarg1;
29373   {
29374     try {
29375       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
29376     } catch (std::out_of_range& e) {
29377       {
29378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29379       };
29380     } catch (std::exception& e) {
29381       {
29382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29383       };
29384     } catch (...) {
29385       {
29386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29387       };
29388     }
29389   }
29390   jresult = SWIG_csharp_string_callback(result->c_str());
29391   return jresult;
29392 }
29393
29394
29395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
29396   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29397   std::string *arg2 = 0 ;
29398
29399   arg1 = (Dali::Actor *)jarg1;
29400   if (!jarg2) {
29401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29402     return ;
29403   }
29404   std::string arg2_str(jarg2);
29405   arg2 = &arg2_str;
29406   {
29407     try {
29408       (arg1)->SetName((std::string const &)*arg2);
29409     } catch (std::out_of_range& e) {
29410       {
29411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29412       };
29413     } catch (std::exception& e) {
29414       {
29415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29416       };
29417     } catch (...) {
29418       {
29419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29420       };
29421     }
29422   }
29423
29424   //argout typemap for const std::string&
29425
29426 }
29427
29428
29429 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
29430   unsigned int jresult ;
29431   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29432   unsigned int result;
29433
29434   arg1 = (Dali::Actor *)jarg1;
29435   {
29436     try {
29437       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
29438     } catch (std::out_of_range& e) {
29439       {
29440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29441       };
29442     } catch (std::exception& e) {
29443       {
29444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29445       };
29446     } catch (...) {
29447       {
29448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29449       };
29450     }
29451   }
29452   jresult = result;
29453   return jresult;
29454 }
29455
29456
29457 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
29458   unsigned int jresult ;
29459   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29460   bool result;
29461
29462   arg1 = (Dali::Actor *)jarg1;
29463   {
29464     try {
29465       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
29466     } catch (std::out_of_range& e) {
29467       {
29468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29469       };
29470     } catch (std::exception& e) {
29471       {
29472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29473       };
29474     } catch (...) {
29475       {
29476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29477       };
29478     }
29479   }
29480   jresult = result;
29481   return jresult;
29482 }
29483
29484
29485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
29486   unsigned int jresult ;
29487   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29488   bool result;
29489
29490   arg1 = (Dali::Actor *)jarg1;
29491   {
29492     try {
29493       result = (bool)((Dali::Actor const *)arg1)->OnStage();
29494     } catch (std::out_of_range& e) {
29495       {
29496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29497       };
29498     } catch (std::exception& e) {
29499       {
29500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29501       };
29502     } catch (...) {
29503       {
29504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29505       };
29506     }
29507   }
29508   jresult = result;
29509   return jresult;
29510 }
29511
29512
29513 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
29514   unsigned int jresult ;
29515   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29516   bool result;
29517
29518   arg1 = (Dali::Actor *)jarg1;
29519   {
29520     try {
29521       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
29522     } catch (std::out_of_range& e) {
29523       {
29524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29525       };
29526     } catch (std::exception& e) {
29527       {
29528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29529       };
29530     } catch (...) {
29531       {
29532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29533       };
29534     }
29535   }
29536   jresult = result;
29537   return jresult;
29538 }
29539
29540
29541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
29542   void * jresult ;
29543   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29544   Dali::Layer result;
29545
29546   arg1 = (Dali::Actor *)jarg1;
29547   {
29548     try {
29549       result = (arg1)->GetLayer();
29550     } catch (std::out_of_range& e) {
29551       {
29552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29553       };
29554     } catch (std::exception& e) {
29555       {
29556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29557       };
29558     } catch (...) {
29559       {
29560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29561       };
29562     }
29563   }
29564   jresult = new Dali::Layer((const Dali::Layer &)result);
29565   return jresult;
29566 }
29567
29568
29569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
29570   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29571   Dali::Actor arg2 ;
29572   Dali::Actor *argp2 ;
29573
29574   arg1 = (Dali::Actor *)jarg1;
29575   argp2 = (Dali::Actor *)jarg2;
29576   if (!argp2) {
29577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29578     return ;
29579   }
29580   arg2 = *argp2;
29581   {
29582     try {
29583       (arg1)->Add(arg2);
29584     } catch (std::out_of_range& e) {
29585       {
29586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29587       };
29588     } catch (std::exception& e) {
29589       {
29590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29591       };
29592     } catch (...) {
29593       {
29594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29595       };
29596     }
29597   }
29598 }
29599
29600
29601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
29602   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29603   Dali::Actor arg2 ;
29604   Dali::Actor *argp2 ;
29605
29606   arg1 = (Dali::Actor *)jarg1;
29607   argp2 = (Dali::Actor *)jarg2;
29608   if (!argp2) {
29609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29610     return ;
29611   }
29612   arg2 = *argp2;
29613   {
29614     try {
29615       (arg1)->Remove(arg2);
29616     } catch (std::out_of_range& e) {
29617       {
29618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29619       };
29620     } catch (std::exception& e) {
29621       {
29622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29623       };
29624     } catch (...) {
29625       {
29626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29627       };
29628     }
29629   }
29630 }
29631
29632
29633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
29634   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29635
29636   arg1 = (Dali::Actor *)jarg1;
29637   {
29638     try {
29639       (arg1)->Unparent();
29640     } catch (std::out_of_range& e) {
29641       {
29642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29643       };
29644     } catch (std::exception& e) {
29645       {
29646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29647       };
29648     } catch (...) {
29649       {
29650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29651       };
29652     }
29653   }
29654 }
29655
29656
29657 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
29658   unsigned int jresult ;
29659   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29660   unsigned int result;
29661
29662   arg1 = (Dali::Actor *)jarg1;
29663   {
29664     try {
29665       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
29666     } catch (std::out_of_range& e) {
29667       {
29668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29669       };
29670     } catch (std::exception& e) {
29671       {
29672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29673       };
29674     } catch (...) {
29675       {
29676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29677       };
29678     }
29679   }
29680   jresult = result;
29681   return jresult;
29682 }
29683
29684
29685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
29686   void * jresult ;
29687   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29688   unsigned int arg2 ;
29689   Dali::Actor result;
29690
29691   arg1 = (Dali::Actor *)jarg1;
29692   arg2 = (unsigned int)jarg2;
29693   {
29694     try {
29695       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
29696     } catch (std::out_of_range& e) {
29697       {
29698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29699       };
29700     } catch (std::exception& e) {
29701       {
29702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29703       };
29704     } catch (...) {
29705       {
29706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29707       };
29708     }
29709   }
29710   jresult = new Dali::Actor((const Dali::Actor &)result);
29711   return jresult;
29712 }
29713
29714
29715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
29716   void * jresult ;
29717   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29718   std::string *arg2 = 0 ;
29719   Dali::Actor result;
29720
29721   arg1 = (Dali::Actor *)jarg1;
29722   if (!jarg2) {
29723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29724     return 0;
29725   }
29726   std::string arg2_str(jarg2);
29727   arg2 = &arg2_str;
29728   {
29729     try {
29730       result = (arg1)->FindChildByName((std::string const &)*arg2);
29731     } catch (std::out_of_range& e) {
29732       {
29733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29734       };
29735     } catch (std::exception& e) {
29736       {
29737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29738       };
29739     } catch (...) {
29740       {
29741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29742       };
29743     }
29744   }
29745   jresult = new Dali::Actor((const Dali::Actor &)result);
29746
29747   //argout typemap for const std::string&
29748
29749   return jresult;
29750 }
29751
29752
29753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
29754   void * jresult ;
29755   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29756   unsigned int arg2 ;
29757   Dali::Actor result;
29758
29759   arg1 = (Dali::Actor *)jarg1;
29760   arg2 = (unsigned int)jarg2;
29761   {
29762     try {
29763       result = (arg1)->FindChildById(arg2);
29764     } catch (std::out_of_range& e) {
29765       {
29766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29767       };
29768     } catch (std::exception& e) {
29769       {
29770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29771       };
29772     } catch (...) {
29773       {
29774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29775       };
29776     }
29777   }
29778   jresult = new Dali::Actor((const Dali::Actor &)result);
29779   return jresult;
29780 }
29781
29782
29783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
29784   void * jresult ;
29785   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29786   Dali::Actor result;
29787
29788   arg1 = (Dali::Actor *)jarg1;
29789   {
29790     try {
29791       result = ((Dali::Actor const *)arg1)->GetParent();
29792     } catch (std::out_of_range& e) {
29793       {
29794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29795       };
29796     } catch (std::exception& e) {
29797       {
29798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29799       };
29800     } catch (...) {
29801       {
29802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29803       };
29804     }
29805   }
29806   jresult = new Dali::Actor((const Dali::Actor &)result);
29807   return jresult;
29808 }
29809
29810
29811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
29812   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29813   Dali::Vector3 *arg2 = 0 ;
29814
29815   arg1 = (Dali::Actor *)jarg1;
29816   arg2 = (Dali::Vector3 *)jarg2;
29817   if (!arg2) {
29818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29819     return ;
29820   }
29821   {
29822     try {
29823       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
29824     } catch (std::out_of_range& e) {
29825       {
29826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29827       };
29828     } catch (std::exception& e) {
29829       {
29830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29831       };
29832     } catch (...) {
29833       {
29834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29835       };
29836     }
29837   }
29838 }
29839
29840
29841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
29842   void * jresult ;
29843   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29844   Dali::Vector3 result;
29845
29846   arg1 = (Dali::Actor *)jarg1;
29847   {
29848     try {
29849       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
29850     } catch (std::out_of_range& e) {
29851       {
29852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29853       };
29854     } catch (std::exception& e) {
29855       {
29856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29857       };
29858     } catch (...) {
29859       {
29860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29861       };
29862     }
29863   }
29864   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29865   return jresult;
29866 }
29867
29868
29869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
29870   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29871   Dali::Vector3 *arg2 = 0 ;
29872
29873   arg1 = (Dali::Actor *)jarg1;
29874   arg2 = (Dali::Vector3 *)jarg2;
29875   if (!arg2) {
29876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29877     return ;
29878   }
29879   {
29880     try {
29881       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
29882     } catch (std::out_of_range& e) {
29883       {
29884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29885       };
29886     } catch (std::exception& e) {
29887       {
29888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29889       };
29890     } catch (...) {
29891       {
29892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29893       };
29894     }
29895   }
29896 }
29897
29898
29899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
29900   void * jresult ;
29901   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29902   Dali::Vector3 result;
29903
29904   arg1 = (Dali::Actor *)jarg1;
29905   {
29906     try {
29907       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
29908     } catch (std::out_of_range& e) {
29909       {
29910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29911       };
29912     } catch (std::exception& e) {
29913       {
29914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29915       };
29916     } catch (...) {
29917       {
29918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29919       };
29920     }
29921   }
29922   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29923   return jresult;
29924 }
29925
29926
29927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
29928   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29929   float arg2 ;
29930   float arg3 ;
29931
29932   arg1 = (Dali::Actor *)jarg1;
29933   arg2 = (float)jarg2;
29934   arg3 = (float)jarg3;
29935   {
29936     try {
29937       (arg1)->SetSize(arg2,arg3);
29938     } catch (std::out_of_range& e) {
29939       {
29940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29941       };
29942     } catch (std::exception& e) {
29943       {
29944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29945       };
29946     } catch (...) {
29947       {
29948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29949       };
29950     }
29951   }
29952 }
29953
29954
29955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
29956   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29957   float arg2 ;
29958   float arg3 ;
29959   float arg4 ;
29960
29961   arg1 = (Dali::Actor *)jarg1;
29962   arg2 = (float)jarg2;
29963   arg3 = (float)jarg3;
29964   arg4 = (float)jarg4;
29965   {
29966     try {
29967       (arg1)->SetSize(arg2,arg3,arg4);
29968     } catch (std::out_of_range& e) {
29969       {
29970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29971       };
29972     } catch (std::exception& e) {
29973       {
29974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29975       };
29976     } catch (...) {
29977       {
29978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29979       };
29980     }
29981   }
29982 }
29983
29984
29985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
29986   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29987   Dali::Vector2 *arg2 = 0 ;
29988
29989   arg1 = (Dali::Actor *)jarg1;
29990   arg2 = (Dali::Vector2 *)jarg2;
29991   if (!arg2) {
29992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
29993     return ;
29994   }
29995   {
29996     try {
29997       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
29998     } catch (std::out_of_range& e) {
29999       {
30000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30001       };
30002     } catch (std::exception& e) {
30003       {
30004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30005       };
30006     } catch (...) {
30007       {
30008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30009       };
30010     }
30011   }
30012 }
30013
30014
30015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
30016   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30017   Dali::Vector3 *arg2 = 0 ;
30018
30019   arg1 = (Dali::Actor *)jarg1;
30020   arg2 = (Dali::Vector3 *)jarg2;
30021   if (!arg2) {
30022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30023     return ;
30024   }
30025   {
30026     try {
30027       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
30028     } catch (std::out_of_range& e) {
30029       {
30030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30031       };
30032     } catch (std::exception& e) {
30033       {
30034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30035       };
30036     } catch (...) {
30037       {
30038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30039       };
30040     }
30041   }
30042 }
30043
30044
30045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
30046   void * jresult ;
30047   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30048   Dali::Vector3 result;
30049
30050   arg1 = (Dali::Actor *)jarg1;
30051   {
30052     try {
30053       result = ((Dali::Actor const *)arg1)->GetTargetSize();
30054     } catch (std::out_of_range& e) {
30055       {
30056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30057       };
30058     } catch (std::exception& e) {
30059       {
30060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30061       };
30062     } catch (...) {
30063       {
30064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30065       };
30066     }
30067   }
30068   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30069   return jresult;
30070 }
30071
30072
30073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
30074   void * jresult ;
30075   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30076   Dali::Vector3 result;
30077
30078   arg1 = (Dali::Actor *)jarg1;
30079   {
30080     try {
30081       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
30082     } catch (std::out_of_range& e) {
30083       {
30084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30085       };
30086     } catch (std::exception& e) {
30087       {
30088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30089       };
30090     } catch (...) {
30091       {
30092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30093       };
30094     }
30095   }
30096   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30097   return jresult;
30098 }
30099
30100
30101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
30102   void * jresult ;
30103   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30104   Dali::Vector3 result;
30105
30106   arg1 = (Dali::Actor *)jarg1;
30107   {
30108     try {
30109       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
30110     } catch (std::out_of_range& e) {
30111       {
30112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30113       };
30114     } catch (std::exception& e) {
30115       {
30116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30117       };
30118     } catch (...) {
30119       {
30120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30121       };
30122     }
30123   }
30124   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30125   return jresult;
30126 }
30127
30128
30129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
30130   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30131   float arg2 ;
30132   float arg3 ;
30133
30134   arg1 = (Dali::Actor *)jarg1;
30135   arg2 = (float)jarg2;
30136   arg3 = (float)jarg3;
30137   {
30138     try {
30139       (arg1)->SetPosition(arg2,arg3);
30140     } catch (std::out_of_range& e) {
30141       {
30142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30143       };
30144     } catch (std::exception& e) {
30145       {
30146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30147       };
30148     } catch (...) {
30149       {
30150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30151       };
30152     }
30153   }
30154 }
30155
30156
30157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30158   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30159   float arg2 ;
30160   float arg3 ;
30161   float arg4 ;
30162
30163   arg1 = (Dali::Actor *)jarg1;
30164   arg2 = (float)jarg2;
30165   arg3 = (float)jarg3;
30166   arg4 = (float)jarg4;
30167   {
30168     try {
30169       (arg1)->SetPosition(arg2,arg3,arg4);
30170     } catch (std::out_of_range& e) {
30171       {
30172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30173       };
30174     } catch (std::exception& e) {
30175       {
30176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30177       };
30178     } catch (...) {
30179       {
30180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30181       };
30182     }
30183   }
30184 }
30185
30186
30187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
30188   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30189   Dali::Vector3 *arg2 = 0 ;
30190
30191   arg1 = (Dali::Actor *)jarg1;
30192   arg2 = (Dali::Vector3 *)jarg2;
30193   if (!arg2) {
30194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30195     return ;
30196   }
30197   {
30198     try {
30199       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
30200     } catch (std::out_of_range& e) {
30201       {
30202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30203       };
30204     } catch (std::exception& e) {
30205       {
30206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30207       };
30208     } catch (...) {
30209       {
30210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30211       };
30212     }
30213   }
30214 }
30215
30216
30217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
30218   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30219   float arg2 ;
30220
30221   arg1 = (Dali::Actor *)jarg1;
30222   arg2 = (float)jarg2;
30223   {
30224     try {
30225       (arg1)->SetX(arg2);
30226     } catch (std::out_of_range& e) {
30227       {
30228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30229       };
30230     } catch (std::exception& e) {
30231       {
30232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30233       };
30234     } catch (...) {
30235       {
30236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30237       };
30238     }
30239   }
30240 }
30241
30242
30243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
30244   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30245   float arg2 ;
30246
30247   arg1 = (Dali::Actor *)jarg1;
30248   arg2 = (float)jarg2;
30249   {
30250     try {
30251       (arg1)->SetY(arg2);
30252     } catch (std::out_of_range& e) {
30253       {
30254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30255       };
30256     } catch (std::exception& e) {
30257       {
30258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30259       };
30260     } catch (...) {
30261       {
30262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30263       };
30264     }
30265   }
30266 }
30267
30268
30269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
30270   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30271   float arg2 ;
30272
30273   arg1 = (Dali::Actor *)jarg1;
30274   arg2 = (float)jarg2;
30275   {
30276     try {
30277       (arg1)->SetZ(arg2);
30278     } catch (std::out_of_range& e) {
30279       {
30280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30281       };
30282     } catch (std::exception& e) {
30283       {
30284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30285       };
30286     } catch (...) {
30287       {
30288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30289       };
30290     }
30291   }
30292 }
30293
30294
30295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
30296   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30297   Dali::Vector3 *arg2 = 0 ;
30298
30299   arg1 = (Dali::Actor *)jarg1;
30300   arg2 = (Dali::Vector3 *)jarg2;
30301   if (!arg2) {
30302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30303     return ;
30304   }
30305   {
30306     try {
30307       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
30308     } catch (std::out_of_range& e) {
30309       {
30310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30311       };
30312     } catch (std::exception& e) {
30313       {
30314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30315       };
30316     } catch (...) {
30317       {
30318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30319       };
30320     }
30321   }
30322 }
30323
30324
30325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
30326   void * jresult ;
30327   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30328   Dali::Vector3 result;
30329
30330   arg1 = (Dali::Actor *)jarg1;
30331   {
30332     try {
30333       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
30334     } catch (std::out_of_range& e) {
30335       {
30336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30337       };
30338     } catch (std::exception& e) {
30339       {
30340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30341       };
30342     } catch (...) {
30343       {
30344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30345       };
30346     }
30347   }
30348   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30349   return jresult;
30350 }
30351
30352
30353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
30354   void * jresult ;
30355   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30356   Dali::Vector3 result;
30357
30358   arg1 = (Dali::Actor *)jarg1;
30359   {
30360     try {
30361       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
30362     } catch (std::out_of_range& e) {
30363       {
30364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30365       };
30366     } catch (std::exception& e) {
30367       {
30368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30369       };
30370     } catch (...) {
30371       {
30372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30373       };
30374     }
30375   }
30376   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30377   return jresult;
30378 }
30379
30380
30381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
30382   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30383   bool arg2 ;
30384
30385   arg1 = (Dali::Actor *)jarg1;
30386   arg2 = jarg2 ? true : false;
30387   {
30388     try {
30389       (arg1)->SetInheritPosition(arg2);
30390     } catch (std::out_of_range& e) {
30391       {
30392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30393       };
30394     } catch (std::exception& e) {
30395       {
30396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30397       };
30398     } catch (...) {
30399       {
30400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30401       };
30402     }
30403   }
30404 }
30405
30406
30407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
30408   int jresult ;
30409   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30410   Dali::PositionInheritanceMode result;
30411
30412   arg1 = (Dali::Actor *)jarg1;
30413   {
30414     try {
30415       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
30416     } catch (std::out_of_range& e) {
30417       {
30418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30419       };
30420     } catch (std::exception& e) {
30421       {
30422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30423       };
30424     } catch (...) {
30425       {
30426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30427       };
30428     }
30429   }
30430   jresult = (int)result;
30431   return jresult;
30432 }
30433
30434
30435 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
30436   unsigned int jresult ;
30437   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30438   bool result;
30439
30440   arg1 = (Dali::Actor *)jarg1;
30441   {
30442     try {
30443       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
30444     } catch (std::out_of_range& e) {
30445       {
30446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30447       };
30448     } catch (std::exception& e) {
30449       {
30450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30451       };
30452     } catch (...) {
30453       {
30454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30455       };
30456     }
30457   }
30458   jresult = result;
30459   return jresult;
30460 }
30461
30462
30463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30464   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30465   Dali::Degree *arg2 = 0 ;
30466   Dali::Vector3 *arg3 = 0 ;
30467
30468   arg1 = (Dali::Actor *)jarg1;
30469   arg2 = (Dali::Degree *)jarg2;
30470   if (!arg2) {
30471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30472     return ;
30473   }
30474   arg3 = (Dali::Vector3 *)jarg3;
30475   if (!arg3) {
30476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30477     return ;
30478   }
30479   {
30480     try {
30481       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30482     } catch (std::out_of_range& e) {
30483       {
30484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30485       };
30486     } catch (std::exception& e) {
30487       {
30488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30489       };
30490     } catch (...) {
30491       {
30492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30493       };
30494     }
30495   }
30496 }
30497
30498
30499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30500   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30501   Dali::Radian *arg2 = 0 ;
30502   Dali::Vector3 *arg3 = 0 ;
30503
30504   arg1 = (Dali::Actor *)jarg1;
30505   arg2 = (Dali::Radian *)jarg2;
30506   if (!arg2) {
30507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30508     return ;
30509   }
30510   arg3 = (Dali::Vector3 *)jarg3;
30511   if (!arg3) {
30512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30513     return ;
30514   }
30515   {
30516     try {
30517       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30518     } catch (std::out_of_range& e) {
30519       {
30520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30521       };
30522     } catch (std::exception& e) {
30523       {
30524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30525       };
30526     } catch (...) {
30527       {
30528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30529       };
30530     }
30531   }
30532 }
30533
30534
30535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
30536   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30537   Dali::Quaternion *arg2 = 0 ;
30538
30539   arg1 = (Dali::Actor *)jarg1;
30540   arg2 = (Dali::Quaternion *)jarg2;
30541   if (!arg2) {
30542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30543     return ;
30544   }
30545   {
30546     try {
30547       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
30548     } catch (std::out_of_range& e) {
30549       {
30550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30551       };
30552     } catch (std::exception& e) {
30553       {
30554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30555       };
30556     } catch (...) {
30557       {
30558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30559       };
30560     }
30561   }
30562 }
30563
30564
30565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30566   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30567   Dali::Degree *arg2 = 0 ;
30568   Dali::Vector3 *arg3 = 0 ;
30569
30570   arg1 = (Dali::Actor *)jarg1;
30571   arg2 = (Dali::Degree *)jarg2;
30572   if (!arg2) {
30573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30574     return ;
30575   }
30576   arg3 = (Dali::Vector3 *)jarg3;
30577   if (!arg3) {
30578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30579     return ;
30580   }
30581   {
30582     try {
30583       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30584     } catch (std::out_of_range& e) {
30585       {
30586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30587       };
30588     } catch (std::exception& e) {
30589       {
30590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30591       };
30592     } catch (...) {
30593       {
30594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30595       };
30596     }
30597   }
30598 }
30599
30600
30601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30602   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30603   Dali::Radian *arg2 = 0 ;
30604   Dali::Vector3 *arg3 = 0 ;
30605
30606   arg1 = (Dali::Actor *)jarg1;
30607   arg2 = (Dali::Radian *)jarg2;
30608   if (!arg2) {
30609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30610     return ;
30611   }
30612   arg3 = (Dali::Vector3 *)jarg3;
30613   if (!arg3) {
30614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30615     return ;
30616   }
30617   {
30618     try {
30619       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30620     } catch (std::out_of_range& e) {
30621       {
30622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30623       };
30624     } catch (std::exception& e) {
30625       {
30626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30627       };
30628     } catch (...) {
30629       {
30630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30631       };
30632     }
30633   }
30634 }
30635
30636
30637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
30638   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30639   Dali::Quaternion *arg2 = 0 ;
30640
30641   arg1 = (Dali::Actor *)jarg1;
30642   arg2 = (Dali::Quaternion *)jarg2;
30643   if (!arg2) {
30644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30645     return ;
30646   }
30647   {
30648     try {
30649       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
30650     } catch (std::out_of_range& e) {
30651       {
30652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30653       };
30654     } catch (std::exception& e) {
30655       {
30656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30657       };
30658     } catch (...) {
30659       {
30660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30661       };
30662     }
30663   }
30664 }
30665
30666
30667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
30668   void * jresult ;
30669   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30670   Dali::Quaternion result;
30671
30672   arg1 = (Dali::Actor *)jarg1;
30673   {
30674     try {
30675       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
30676     } catch (std::out_of_range& e) {
30677       {
30678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30679       };
30680     } catch (std::exception& e) {
30681       {
30682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30683       };
30684     } catch (...) {
30685       {
30686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30687       };
30688     }
30689   }
30690   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30691   return jresult;
30692 }
30693
30694
30695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
30696   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30697   bool arg2 ;
30698
30699   arg1 = (Dali::Actor *)jarg1;
30700   arg2 = jarg2 ? true : false;
30701   {
30702     try {
30703       (arg1)->SetInheritOrientation(arg2);
30704     } catch (std::out_of_range& e) {
30705       {
30706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30707       };
30708     } catch (std::exception& e) {
30709       {
30710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30711       };
30712     } catch (...) {
30713       {
30714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30715       };
30716     }
30717   }
30718 }
30719
30720
30721 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
30722   unsigned int jresult ;
30723   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30724   bool result;
30725
30726   arg1 = (Dali::Actor *)jarg1;
30727   {
30728     try {
30729       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
30730     } catch (std::out_of_range& e) {
30731       {
30732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30733       };
30734     } catch (std::exception& e) {
30735       {
30736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30737       };
30738     } catch (...) {
30739       {
30740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30741       };
30742     }
30743   }
30744   jresult = result;
30745   return jresult;
30746 }
30747
30748
30749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
30750   void * jresult ;
30751   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30752   Dali::Quaternion result;
30753
30754   arg1 = (Dali::Actor *)jarg1;
30755   {
30756     try {
30757       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
30758     } catch (std::out_of_range& e) {
30759       {
30760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30761       };
30762     } catch (std::exception& e) {
30763       {
30764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30765       };
30766     } catch (...) {
30767       {
30768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30769       };
30770     }
30771   }
30772   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30773   return jresult;
30774 }
30775
30776
30777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
30778   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30779   float arg2 ;
30780
30781   arg1 = (Dali::Actor *)jarg1;
30782   arg2 = (float)jarg2;
30783   {
30784     try {
30785       (arg1)->SetScale(arg2);
30786     } catch (std::out_of_range& e) {
30787       {
30788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30789       };
30790     } catch (std::exception& e) {
30791       {
30792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30793       };
30794     } catch (...) {
30795       {
30796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30797       };
30798     }
30799   }
30800 }
30801
30802
30803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30804   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30805   float arg2 ;
30806   float arg3 ;
30807   float arg4 ;
30808
30809   arg1 = (Dali::Actor *)jarg1;
30810   arg2 = (float)jarg2;
30811   arg3 = (float)jarg3;
30812   arg4 = (float)jarg4;
30813   {
30814     try {
30815       (arg1)->SetScale(arg2,arg3,arg4);
30816     } catch (std::out_of_range& e) {
30817       {
30818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30819       };
30820     } catch (std::exception& e) {
30821       {
30822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30823       };
30824     } catch (...) {
30825       {
30826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30827       };
30828     }
30829   }
30830 }
30831
30832
30833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
30834   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30835   Dali::Vector3 *arg2 = 0 ;
30836
30837   arg1 = (Dali::Actor *)jarg1;
30838   arg2 = (Dali::Vector3 *)jarg2;
30839   if (!arg2) {
30840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30841     return ;
30842   }
30843   {
30844     try {
30845       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
30846     } catch (std::out_of_range& e) {
30847       {
30848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30849       };
30850     } catch (std::exception& e) {
30851       {
30852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30853       };
30854     } catch (...) {
30855       {
30856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30857       };
30858     }
30859   }
30860 }
30861
30862
30863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
30864   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30865   Dali::Vector3 *arg2 = 0 ;
30866
30867   arg1 = (Dali::Actor *)jarg1;
30868   arg2 = (Dali::Vector3 *)jarg2;
30869   if (!arg2) {
30870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30871     return ;
30872   }
30873   {
30874     try {
30875       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
30876     } catch (std::out_of_range& e) {
30877       {
30878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30879       };
30880     } catch (std::exception& e) {
30881       {
30882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30883       };
30884     } catch (...) {
30885       {
30886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30887       };
30888     }
30889   }
30890 }
30891
30892
30893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
30894   void * jresult ;
30895   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30896   Dali::Vector3 result;
30897
30898   arg1 = (Dali::Actor *)jarg1;
30899   {
30900     try {
30901       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
30902     } catch (std::out_of_range& e) {
30903       {
30904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30905       };
30906     } catch (std::exception& e) {
30907       {
30908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30909       };
30910     } catch (...) {
30911       {
30912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30913       };
30914     }
30915   }
30916   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30917   return jresult;
30918 }
30919
30920
30921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
30922   void * jresult ;
30923   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30924   Dali::Vector3 result;
30925
30926   arg1 = (Dali::Actor *)jarg1;
30927   {
30928     try {
30929       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
30930     } catch (std::out_of_range& e) {
30931       {
30932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30933       };
30934     } catch (std::exception& e) {
30935       {
30936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30937       };
30938     } catch (...) {
30939       {
30940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30941       };
30942     }
30943   }
30944   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30945   return jresult;
30946 }
30947
30948
30949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
30950   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30951   bool arg2 ;
30952
30953   arg1 = (Dali::Actor *)jarg1;
30954   arg2 = jarg2 ? true : false;
30955   {
30956     try {
30957       (arg1)->SetInheritScale(arg2);
30958     } catch (std::out_of_range& e) {
30959       {
30960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30961       };
30962     } catch (std::exception& e) {
30963       {
30964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30965       };
30966     } catch (...) {
30967       {
30968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30969       };
30970     }
30971   }
30972 }
30973
30974
30975 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
30976   unsigned int jresult ;
30977   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30978   bool result;
30979
30980   arg1 = (Dali::Actor *)jarg1;
30981   {
30982     try {
30983       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
30984     } catch (std::out_of_range& e) {
30985       {
30986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30987       };
30988     } catch (std::exception& e) {
30989       {
30990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30991       };
30992     } catch (...) {
30993       {
30994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30995       };
30996     }
30997   }
30998   jresult = result;
30999   return jresult;
31000 }
31001
31002
31003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
31004   void * jresult ;
31005   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31006   Dali::Matrix result;
31007
31008   arg1 = (Dali::Actor *)jarg1;
31009   {
31010     try {
31011       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
31012     } catch (std::out_of_range& e) {
31013       {
31014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31015       };
31016     } catch (std::exception& e) {
31017       {
31018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31019       };
31020     } catch (...) {
31021       {
31022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31023       };
31024     }
31025   }
31026   jresult = new Dali::Matrix((const Dali::Matrix &)result);
31027   return jresult;
31028 }
31029
31030
31031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
31032   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31033   bool arg2 ;
31034
31035   arg1 = (Dali::Actor *)jarg1;
31036   arg2 = jarg2 ? true : false;
31037   {
31038     try {
31039       (arg1)->SetVisible(arg2);
31040     } catch (std::out_of_range& e) {
31041       {
31042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31043       };
31044     } catch (std::exception& e) {
31045       {
31046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31047       };
31048     } catch (...) {
31049       {
31050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31051       };
31052     }
31053   }
31054 }
31055
31056
31057 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
31058   unsigned int jresult ;
31059   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31060   bool result;
31061
31062   arg1 = (Dali::Actor *)jarg1;
31063   {
31064     try {
31065       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
31066     } catch (std::out_of_range& e) {
31067       {
31068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31069       };
31070     } catch (std::exception& e) {
31071       {
31072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31073       };
31074     } catch (...) {
31075       {
31076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31077       };
31078     }
31079   }
31080   jresult = result;
31081   return jresult;
31082 }
31083
31084
31085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
31086   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31087   float arg2 ;
31088
31089   arg1 = (Dali::Actor *)jarg1;
31090   arg2 = (float)jarg2;
31091   {
31092     try {
31093       (arg1)->SetOpacity(arg2);
31094     } catch (std::out_of_range& e) {
31095       {
31096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31097       };
31098     } catch (std::exception& e) {
31099       {
31100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31101       };
31102     } catch (...) {
31103       {
31104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31105       };
31106     }
31107   }
31108 }
31109
31110
31111 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
31112   float jresult ;
31113   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31114   float result;
31115
31116   arg1 = (Dali::Actor *)jarg1;
31117   {
31118     try {
31119       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
31120     } catch (std::out_of_range& e) {
31121       {
31122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31123       };
31124     } catch (std::exception& e) {
31125       {
31126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31127       };
31128     } catch (...) {
31129       {
31130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31131       };
31132     }
31133   }
31134   jresult = result;
31135   return jresult;
31136 }
31137
31138
31139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
31140   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31141   Dali::Vector4 *arg2 = 0 ;
31142
31143   arg1 = (Dali::Actor *)jarg1;
31144   arg2 = (Dali::Vector4 *)jarg2;
31145   if (!arg2) {
31146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
31147     return ;
31148   }
31149   {
31150     try {
31151       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
31152     } catch (std::out_of_range& e) {
31153       {
31154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31155       };
31156     } catch (std::exception& e) {
31157       {
31158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31159       };
31160     } catch (...) {
31161       {
31162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31163       };
31164     }
31165   }
31166 }
31167
31168
31169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
31170   void * jresult ;
31171   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31172   Dali::Vector4 result;
31173
31174   arg1 = (Dali::Actor *)jarg1;
31175   {
31176     try {
31177       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
31178     } catch (std::out_of_range& e) {
31179       {
31180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31181       };
31182     } catch (std::exception& e) {
31183       {
31184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31185       };
31186     } catch (...) {
31187       {
31188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31189       };
31190     }
31191   }
31192   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31193   return jresult;
31194 }
31195
31196
31197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
31198   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31199   Dali::ColorMode arg2 ;
31200
31201   arg1 = (Dali::Actor *)jarg1;
31202   arg2 = (Dali::ColorMode)jarg2;
31203   {
31204     try {
31205       (arg1)->SetColorMode(arg2);
31206     } catch (std::out_of_range& e) {
31207       {
31208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31209       };
31210     } catch (std::exception& e) {
31211       {
31212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31213       };
31214     } catch (...) {
31215       {
31216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31217       };
31218     }
31219   }
31220 }
31221
31222
31223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
31224   int jresult ;
31225   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31226   Dali::ColorMode result;
31227
31228   arg1 = (Dali::Actor *)jarg1;
31229   {
31230     try {
31231       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
31232     } catch (std::out_of_range& e) {
31233       {
31234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31235       };
31236     } catch (std::exception& e) {
31237       {
31238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31239       };
31240     } catch (...) {
31241       {
31242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31243       };
31244     }
31245   }
31246   jresult = (int)result;
31247   return jresult;
31248 }
31249
31250
31251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
31252   void * jresult ;
31253   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31254   Dali::Vector4 result;
31255
31256   arg1 = (Dali::Actor *)jarg1;
31257   {
31258     try {
31259       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
31260     } catch (std::out_of_range& e) {
31261       {
31262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31263       };
31264     } catch (std::exception& e) {
31265       {
31266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31267       };
31268     } catch (...) {
31269       {
31270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31271       };
31272     }
31273   }
31274   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31275   return jresult;
31276 }
31277
31278
31279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
31280   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31281   Dali::DrawMode::Type arg2 ;
31282
31283   arg1 = (Dali::Actor *)jarg1;
31284   arg2 = (Dali::DrawMode::Type)jarg2;
31285   {
31286     try {
31287       (arg1)->SetDrawMode(arg2);
31288     } catch (std::out_of_range& e) {
31289       {
31290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31291       };
31292     } catch (std::exception& e) {
31293       {
31294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31295       };
31296     } catch (...) {
31297       {
31298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31299       };
31300     }
31301   }
31302 }
31303
31304
31305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
31306   int jresult ;
31307   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31308   Dali::DrawMode::Type result;
31309
31310   arg1 = (Dali::Actor *)jarg1;
31311   {
31312     try {
31313       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
31314     } catch (std::out_of_range& e) {
31315       {
31316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31317       };
31318     } catch (std::exception& e) {
31319       {
31320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31321       };
31322     } catch (...) {
31323       {
31324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31325       };
31326     }
31327   }
31328   jresult = (int)result;
31329   return jresult;
31330 }
31331
31332
31333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
31334   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31335   bool arg2 ;
31336
31337   arg1 = (Dali::Actor *)jarg1;
31338   arg2 = jarg2 ? true : false;
31339   {
31340     try {
31341       (arg1)->SetSensitive(arg2);
31342     } catch (std::out_of_range& e) {
31343       {
31344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31345       };
31346     } catch (std::exception& e) {
31347       {
31348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31349       };
31350     } catch (...) {
31351       {
31352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31353       };
31354     }
31355   }
31356 }
31357
31358
31359 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
31360   unsigned int jresult ;
31361   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31362   bool result;
31363
31364   arg1 = (Dali::Actor *)jarg1;
31365   {
31366     try {
31367       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
31368     } catch (std::out_of_range& e) {
31369       {
31370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31371       };
31372     } catch (std::exception& e) {
31373       {
31374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31375       };
31376     } catch (...) {
31377       {
31378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31379       };
31380     }
31381   }
31382   jresult = result;
31383   return jresult;
31384 }
31385
31386
31387 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
31388   unsigned int jresult ;
31389   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31390   float *arg2 = 0 ;
31391   float *arg3 = 0 ;
31392   float arg4 ;
31393   float arg5 ;
31394   bool result;
31395
31396   arg1 = (Dali::Actor *)jarg1;
31397   arg2 = (float *)jarg2;
31398   arg3 = (float *)jarg3;
31399   arg4 = (float)jarg4;
31400   arg5 = (float)jarg5;
31401   {
31402     try {
31403       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
31404     } catch (std::out_of_range& e) {
31405       {
31406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31407       };
31408     } catch (std::exception& e) {
31409       {
31410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31411       };
31412     } catch (...) {
31413       {
31414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31415       };
31416     }
31417   }
31418   jresult = result;
31419   return jresult;
31420 }
31421
31422
31423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
31424   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31425   bool arg2 ;
31426
31427   arg1 = (Dali::Actor *)jarg1;
31428   arg2 = jarg2 ? true : false;
31429   {
31430     try {
31431       (arg1)->SetLeaveRequired(arg2);
31432     } catch (std::out_of_range& e) {
31433       {
31434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31435       };
31436     } catch (std::exception& e) {
31437       {
31438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31439       };
31440     } catch (...) {
31441       {
31442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31443       };
31444     }
31445   }
31446 }
31447
31448
31449 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
31450   unsigned int jresult ;
31451   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31452   bool result;
31453
31454   arg1 = (Dali::Actor *)jarg1;
31455   {
31456     try {
31457       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
31458     } catch (std::out_of_range& e) {
31459       {
31460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31461       };
31462     } catch (std::exception& e) {
31463       {
31464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31465       };
31466     } catch (...) {
31467       {
31468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31469       };
31470     }
31471   }
31472   jresult = result;
31473   return jresult;
31474 }
31475
31476
31477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
31478   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31479   bool arg2 ;
31480
31481   arg1 = (Dali::Actor *)jarg1;
31482   arg2 = jarg2 ? true : false;
31483   {
31484     try {
31485       (arg1)->SetKeyboardFocusable(arg2);
31486     } catch (std::out_of_range& e) {
31487       {
31488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31489       };
31490     } catch (std::exception& e) {
31491       {
31492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31493       };
31494     } catch (...) {
31495       {
31496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31497       };
31498     }
31499   }
31500 }
31501
31502
31503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
31504   unsigned int jresult ;
31505   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31506   bool result;
31507
31508   arg1 = (Dali::Actor *)jarg1;
31509   {
31510     try {
31511       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
31512     } catch (std::out_of_range& e) {
31513       {
31514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31515       };
31516     } catch (std::exception& e) {
31517       {
31518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31519       };
31520     } catch (...) {
31521       {
31522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31523       };
31524     }
31525   }
31526   jresult = result;
31527   return jresult;
31528 }
31529
31530
31531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
31532   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31533   Dali::ResizePolicy::Type arg2 ;
31534   Dali::Dimension::Type arg3 ;
31535
31536   arg1 = (Dali::Actor *)jarg1;
31537   arg2 = (Dali::ResizePolicy::Type)jarg2;
31538   arg3 = (Dali::Dimension::Type)jarg3;
31539   {
31540     try {
31541       (arg1)->SetResizePolicy(arg2,arg3);
31542     } catch (std::out_of_range& e) {
31543       {
31544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31545       };
31546     } catch (std::exception& e) {
31547       {
31548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31549       };
31550     } catch (...) {
31551       {
31552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31553       };
31554     }
31555   }
31556 }
31557
31558
31559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
31560   int jresult ;
31561   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31562   Dali::Dimension::Type arg2 ;
31563   Dali::ResizePolicy::Type result;
31564
31565   arg1 = (Dali::Actor *)jarg1;
31566   arg2 = (Dali::Dimension::Type)jarg2;
31567   {
31568     try {
31569       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
31570     } catch (std::out_of_range& e) {
31571       {
31572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31573       };
31574     } catch (std::exception& e) {
31575       {
31576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31577       };
31578     } catch (...) {
31579       {
31580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31581       };
31582     }
31583   }
31584   jresult = (int)result;
31585   return jresult;
31586 }
31587
31588
31589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
31590   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31591   Dali::SizeScalePolicy::Type arg2 ;
31592
31593   arg1 = (Dali::Actor *)jarg1;
31594   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
31595   {
31596     try {
31597       (arg1)->SetSizeScalePolicy(arg2);
31598     } catch (std::out_of_range& e) {
31599       {
31600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31601       };
31602     } catch (std::exception& e) {
31603       {
31604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31605       };
31606     } catch (...) {
31607       {
31608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31609       };
31610     }
31611   }
31612 }
31613
31614
31615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
31616   int jresult ;
31617   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31618   Dali::SizeScalePolicy::Type result;
31619
31620   arg1 = (Dali::Actor *)jarg1;
31621   {
31622     try {
31623       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
31624     } catch (std::out_of_range& e) {
31625       {
31626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31627       };
31628     } catch (std::exception& e) {
31629       {
31630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31631       };
31632     } catch (...) {
31633       {
31634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31635       };
31636     }
31637   }
31638   jresult = (int)result;
31639   return jresult;
31640 }
31641
31642
31643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
31644   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31645   Dali::Vector3 *arg2 = 0 ;
31646
31647   arg1 = (Dali::Actor *)jarg1;
31648   arg2 = (Dali::Vector3 *)jarg2;
31649   if (!arg2) {
31650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31651     return ;
31652   }
31653   {
31654     try {
31655       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
31656     } catch (std::out_of_range& e) {
31657       {
31658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31659       };
31660     } catch (std::exception& e) {
31661       {
31662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31663       };
31664     } catch (...) {
31665       {
31666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31667       };
31668     }
31669   }
31670 }
31671
31672
31673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
31674   void * jresult ;
31675   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31676   Dali::Vector3 result;
31677
31678   arg1 = (Dali::Actor *)jarg1;
31679   {
31680     try {
31681       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
31682     } catch (std::out_of_range& e) {
31683       {
31684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31685       };
31686     } catch (std::exception& e) {
31687       {
31688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31689       };
31690     } catch (...) {
31691       {
31692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31693       };
31694     }
31695   }
31696   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31697   return jresult;
31698 }
31699
31700
31701 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
31702   float jresult ;
31703   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31704   float arg2 ;
31705   float result;
31706
31707   arg1 = (Dali::Actor *)jarg1;
31708   arg2 = (float)jarg2;
31709   {
31710     try {
31711       result = (float)(arg1)->GetHeightForWidth(arg2);
31712     } catch (std::out_of_range& e) {
31713       {
31714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31715       };
31716     } catch (std::exception& e) {
31717       {
31718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31719       };
31720     } catch (...) {
31721       {
31722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31723       };
31724     }
31725   }
31726   jresult = result;
31727   return jresult;
31728 }
31729
31730
31731 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
31732   float jresult ;
31733   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31734   float arg2 ;
31735   float result;
31736
31737   arg1 = (Dali::Actor *)jarg1;
31738   arg2 = (float)jarg2;
31739   {
31740     try {
31741       result = (float)(arg1)->GetWidthForHeight(arg2);
31742     } catch (std::out_of_range& e) {
31743       {
31744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31745       };
31746     } catch (std::exception& e) {
31747       {
31748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31749       };
31750     } catch (...) {
31751       {
31752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31753       };
31754     }
31755   }
31756   jresult = result;
31757   return jresult;
31758 }
31759
31760
31761 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
31762   float jresult ;
31763   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31764   Dali::Dimension::Type arg2 ;
31765   float result;
31766
31767   arg1 = (Dali::Actor *)jarg1;
31768   arg2 = (Dali::Dimension::Type)jarg2;
31769   {
31770     try {
31771       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
31772     } catch (std::out_of_range& e) {
31773       {
31774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31775       };
31776     } catch (std::exception& e) {
31777       {
31778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31779       };
31780     } catch (...) {
31781       {
31782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31783       };
31784     }
31785   }
31786   jresult = result;
31787   return jresult;
31788 }
31789
31790
31791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
31792   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31793   Dali::Padding *arg2 = 0 ;
31794
31795   arg1 = (Dali::Actor *)jarg1;
31796   arg2 = (Dali::Padding *)jarg2;
31797   if (!arg2) {
31798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
31799     return ;
31800   }
31801   {
31802     try {
31803       (arg1)->SetPadding((Dali::Padding const &)*arg2);
31804     } catch (std::out_of_range& e) {
31805       {
31806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31807       };
31808     } catch (std::exception& e) {
31809       {
31810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31811       };
31812     } catch (...) {
31813       {
31814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31815       };
31816     }
31817   }
31818 }
31819
31820
31821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
31822   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31823   Dali::Padding *arg2 = 0 ;
31824
31825   arg1 = (Dali::Actor *)jarg1;
31826   arg2 = (Dali::Padding *)jarg2;
31827   if (!arg2) {
31828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
31829     return ;
31830   }
31831   {
31832     try {
31833       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
31834     } catch (std::out_of_range& e) {
31835       {
31836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31837       };
31838     } catch (std::exception& e) {
31839       {
31840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31841       };
31842     } catch (...) {
31843       {
31844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31845       };
31846     }
31847   }
31848 }
31849
31850
31851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
31852   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31853   Dali::Vector2 *arg2 = 0 ;
31854
31855   arg1 = (Dali::Actor *)jarg1;
31856   arg2 = (Dali::Vector2 *)jarg2;
31857   if (!arg2) {
31858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31859     return ;
31860   }
31861   {
31862     try {
31863       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
31864     } catch (std::out_of_range& e) {
31865       {
31866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31867       };
31868     } catch (std::exception& e) {
31869       {
31870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31871       };
31872     } catch (...) {
31873       {
31874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31875       };
31876     }
31877   }
31878 }
31879
31880
31881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
31882   void * jresult ;
31883   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31884   Dali::Vector2 result;
31885
31886   arg1 = (Dali::Actor *)jarg1;
31887   {
31888     try {
31889       result = (arg1)->GetMinimumSize();
31890     } catch (std::out_of_range& e) {
31891       {
31892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31893       };
31894     } catch (std::exception& e) {
31895       {
31896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31897       };
31898     } catch (...) {
31899       {
31900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31901       };
31902     }
31903   }
31904   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
31905   return jresult;
31906 }
31907
31908
31909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
31910   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31911   Dali::Vector2 *arg2 = 0 ;
31912
31913   arg1 = (Dali::Actor *)jarg1;
31914   arg2 = (Dali::Vector2 *)jarg2;
31915   if (!arg2) {
31916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31917     return ;
31918   }
31919   {
31920     try {
31921       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
31922     } catch (std::out_of_range& e) {
31923       {
31924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31925       };
31926     } catch (std::exception& e) {
31927       {
31928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31929       };
31930     } catch (...) {
31931       {
31932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31933       };
31934     }
31935   }
31936 }
31937
31938
31939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
31940   void * jresult ;
31941   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31942   Dali::Vector2 result;
31943
31944   arg1 = (Dali::Actor *)jarg1;
31945   {
31946     try {
31947       result = (arg1)->GetMaximumSize();
31948     } catch (std::out_of_range& e) {
31949       {
31950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31951       };
31952     } catch (std::exception& e) {
31953       {
31954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31955       };
31956     } catch (...) {
31957       {
31958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31959       };
31960     }
31961   }
31962   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
31963   return jresult;
31964 }
31965
31966
31967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
31968   int jresult ;
31969   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31970   int result;
31971
31972   arg1 = (Dali::Actor *)jarg1;
31973   {
31974     try {
31975       result = (int)(arg1)->GetHierarchyDepth();
31976     } catch (std::out_of_range& e) {
31977       {
31978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31979       };
31980     } catch (std::exception& e) {
31981       {
31982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31983       };
31984     } catch (...) {
31985       {
31986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31987       };
31988     }
31989   }
31990   jresult = result;
31991   return jresult;
31992 }
31993
31994
31995 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
31996   unsigned int jresult ;
31997   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31998   Dali::Renderer *arg2 = 0 ;
31999   unsigned int result;
32000
32001   arg1 = (Dali::Actor *)jarg1;
32002   arg2 = (Dali::Renderer *)jarg2;
32003   if (!arg2) {
32004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
32005     return 0;
32006   }
32007   {
32008     try {
32009       result = (unsigned int)(arg1)->AddRenderer(*arg2);
32010     } catch (std::out_of_range& e) {
32011       {
32012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32013       };
32014     } catch (std::exception& e) {
32015       {
32016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32017       };
32018     } catch (...) {
32019       {
32020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32021       };
32022     }
32023   }
32024   jresult = result;
32025   return jresult;
32026 }
32027
32028
32029 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
32030   unsigned int jresult ;
32031   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32032   unsigned int result;
32033
32034   arg1 = (Dali::Actor *)jarg1;
32035   {
32036     try {
32037       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
32038     } catch (std::out_of_range& e) {
32039       {
32040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32041       };
32042     } catch (std::exception& e) {
32043       {
32044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32045       };
32046     } catch (...) {
32047       {
32048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32049       };
32050     }
32051   }
32052   jresult = result;
32053   return jresult;
32054 }
32055
32056
32057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
32058   void * jresult ;
32059   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32060   unsigned int arg2 ;
32061   Dali::Renderer result;
32062
32063   arg1 = (Dali::Actor *)jarg1;
32064   arg2 = (unsigned int)jarg2;
32065   {
32066     try {
32067       result = (arg1)->GetRendererAt(arg2);
32068     } catch (std::out_of_range& e) {
32069       {
32070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32071       };
32072     } catch (std::exception& e) {
32073       {
32074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32075       };
32076     } catch (...) {
32077       {
32078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32079       };
32080     }
32081   }
32082   jresult = new Dali::Renderer((const Dali::Renderer &)result);
32083   return jresult;
32084 }
32085
32086
32087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
32088   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32089   Dali::Renderer *arg2 = 0 ;
32090
32091   arg1 = (Dali::Actor *)jarg1;
32092   arg2 = (Dali::Renderer *)jarg2;
32093   if (!arg2) {
32094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
32095     return ;
32096   }
32097   {
32098     try {
32099       (arg1)->RemoveRenderer(*arg2);
32100     } catch (std::out_of_range& e) {
32101       {
32102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32103       };
32104     } catch (std::exception& e) {
32105       {
32106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32107       };
32108     } catch (...) {
32109       {
32110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32111       };
32112     }
32113   }
32114 }
32115
32116
32117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
32118   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32119   unsigned int arg2 ;
32120
32121   arg1 = (Dali::Actor *)jarg1;
32122   arg2 = (unsigned int)jarg2;
32123   {
32124     try {
32125       (arg1)->RemoveRenderer(arg2);
32126     } catch (std::out_of_range& e) {
32127       {
32128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32129       };
32130     } catch (std::exception& e) {
32131       {
32132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32133       };
32134     } catch (...) {
32135       {
32136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32137       };
32138     }
32139   }
32140 }
32141
32142
32143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
32144   void * jresult ;
32145   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32146   Dali::Actor::TouchSignalType *result = 0 ;
32147
32148   arg1 = (Dali::Actor *)jarg1;
32149   {
32150     try {
32151       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
32152     } catch (std::out_of_range& e) {
32153       {
32154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32155       };
32156     } catch (std::exception& e) {
32157       {
32158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32159       };
32160     } catch (...) {
32161       {
32162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32163       };
32164     }
32165   }
32166   jresult = (void *)result;
32167   return jresult;
32168 }
32169
32170
32171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
32172   void * jresult ;
32173   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32174   Dali::Actor::TouchDataSignalType *result = 0 ;
32175
32176   arg1 = (Dali::Actor *)jarg1;
32177   {
32178     try {
32179       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
32180     } catch (std::out_of_range& e) {
32181       {
32182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32183       };
32184     } catch (std::exception& e) {
32185       {
32186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32187       };
32188     } catch (...) {
32189       {
32190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32191       };
32192     }
32193   }
32194   jresult = (void *)result;
32195   return jresult;
32196 }
32197
32198
32199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
32200   void * jresult ;
32201   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32202   Dali::Actor::HoverSignalType *result = 0 ;
32203
32204   arg1 = (Dali::Actor *)jarg1;
32205   {
32206     try {
32207       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
32208     } catch (std::out_of_range& e) {
32209       {
32210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32211       };
32212     } catch (std::exception& e) {
32213       {
32214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32215       };
32216     } catch (...) {
32217       {
32218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32219       };
32220     }
32221   }
32222   jresult = (void *)result;
32223   return jresult;
32224 }
32225
32226
32227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
32228   void * jresult ;
32229   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32230   Dali::Actor::WheelEventSignalType *result = 0 ;
32231
32232   arg1 = (Dali::Actor *)jarg1;
32233   {
32234     try {
32235       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
32236     } catch (std::out_of_range& e) {
32237       {
32238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32239       };
32240     } catch (std::exception& e) {
32241       {
32242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32243       };
32244     } catch (...) {
32245       {
32246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32247       };
32248     }
32249   }
32250   jresult = (void *)result;
32251   return jresult;
32252 }
32253
32254
32255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
32256   void * jresult ;
32257   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32258   Dali::Actor::OnStageSignalType *result = 0 ;
32259
32260   arg1 = (Dali::Actor *)jarg1;
32261   {
32262     try {
32263       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
32264     } catch (std::out_of_range& e) {
32265       {
32266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32267       };
32268     } catch (std::exception& e) {
32269       {
32270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32271       };
32272     } catch (...) {
32273       {
32274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32275       };
32276     }
32277   }
32278   jresult = (void *)result;
32279   return jresult;
32280 }
32281
32282
32283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
32284   void * jresult ;
32285   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32286   Dali::Actor::OffStageSignalType *result = 0 ;
32287
32288   arg1 = (Dali::Actor *)jarg1;
32289   {
32290     try {
32291       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
32292     } catch (std::out_of_range& e) {
32293       {
32294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32295       };
32296     } catch (std::exception& e) {
32297       {
32298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32299       };
32300     } catch (...) {
32301       {
32302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32303       };
32304     }
32305   }
32306   jresult = (void *)result;
32307   return jresult;
32308 }
32309
32310
32311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
32312   void * jresult ;
32313   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32314   Dali::Actor::OnRelayoutSignalType *result = 0 ;
32315
32316   arg1 = (Dali::Actor *)jarg1;
32317   {
32318     try {
32319       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
32320     } catch (std::out_of_range& e) {
32321       {
32322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32323       };
32324     } catch (std::exception& e) {
32325       {
32326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32327       };
32328     } catch (...) {
32329       {
32330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32331       };
32332     }
32333   }
32334   jresult = (void *)result;
32335   return jresult;
32336 }
32337
32338
32339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
32340   Dali::Actor *arg1 = 0 ;
32341
32342   arg1 = (Dali::Actor *)jarg1;
32343   if (!arg1) {
32344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
32345     return ;
32346   }
32347   {
32348     try {
32349       Dali::UnparentAndReset(*arg1);
32350     } catch (std::out_of_range& e) {
32351       {
32352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32353       };
32354     } catch (std::exception& e) {
32355       {
32356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32357       };
32358     } catch (...) {
32359       {
32360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32361       };
32362     }
32363   }
32364 }
32365
32366
32367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32368   Dali::Actor arg1 ;
32369   Dali::Actor *argp1 ;
32370
32371   argp1 = (Dali::Actor *)jarg1;
32372   if (!argp1) {
32373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32374     return ;
32375   }
32376   arg1 = *argp1;
32377   {
32378     try {
32379       Dali::DevelActor::Raise(arg1);
32380     } catch (std::out_of_range& e) {
32381       {
32382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32383       };
32384     } catch (std::exception& e) {
32385       {
32386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32387       };
32388     } catch (...) {
32389       {
32390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32391       };
32392     }
32393   }
32394 }
32395
32396
32397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32398   Dali::Actor arg1 ;
32399   Dali::Actor *argp1 ;
32400
32401   argp1 = (Dali::Actor *)jarg1;
32402   if (!argp1) {
32403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32404     return ;
32405   }
32406   arg1 = *argp1;
32407   {
32408     try {
32409       Dali::DevelActor::Lower(arg1);
32410     } catch (std::out_of_range& e) {
32411       {
32412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32413       };
32414     } catch (std::exception& e) {
32415       {
32416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32417       };
32418     } catch (...) {
32419       {
32420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32421       };
32422     }
32423   }
32424 }
32425
32426
32427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32428   Dali::Actor arg1 ;
32429   Dali::Actor *argp1 ;
32430
32431   argp1 = (Dali::Actor *)jarg1;
32432   if (!argp1) {
32433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32434     return ;
32435   }
32436   arg1 = *argp1;
32437   {
32438     try {
32439       Dali::DevelActor::RaiseToTop(arg1);
32440     } catch (std::out_of_range& e) {
32441       {
32442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32443       };
32444     } catch (std::exception& e) {
32445       {
32446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32447       };
32448     } catch (...) {
32449       {
32450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32451       };
32452     }
32453   }
32454 }
32455
32456
32457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32458   Dali::Actor arg1 ;
32459   Dali::Actor *argp1 ;
32460
32461   argp1 = (Dali::Actor *)jarg1;
32462   if (!argp1) {
32463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32464     return ;
32465   }
32466   arg1 = *argp1;
32467   {
32468     try {
32469       Dali::DevelActor::LowerToBottom(arg1);
32470     } catch (std::out_of_range& e) {
32471       {
32472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32473       };
32474     } catch (std::exception& e) {
32475       {
32476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32477       };
32478     } catch (...) {
32479       {
32480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32481       };
32482     }
32483   }
32484 }
32485
32486
32487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32488   Dali::Actor arg1 ;
32489   Dali::Actor arg2 ;
32490   Dali::Actor *argp1 ;
32491   Dali::Actor *argp2 ;
32492
32493   argp1 = (Dali::Actor *)jarg1;
32494   if (!argp1) {
32495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32496     return ;
32497   }
32498   arg1 = *argp1;
32499   argp2 = (Dali::Actor *)jarg2;
32500   if (!argp2) {
32501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32502     return ;
32503   }
32504   arg2 = *argp2;
32505   {
32506     try {
32507       Dali::DevelActor::RaiseAbove(arg1,arg2);
32508     } catch (std::out_of_range& e) {
32509       {
32510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32511       };
32512     } catch (std::exception& e) {
32513       {
32514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32515       };
32516     } catch (...) {
32517       {
32518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32519       };
32520     }
32521   }
32522 }
32523
32524
32525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32526   Dali::Actor arg1 ;
32527   Dali::Actor arg2 ;
32528   Dali::Actor *argp1 ;
32529   Dali::Actor *argp2 ;
32530
32531   argp1 = (Dali::Actor *)jarg1;
32532   if (!argp1) {
32533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32534     return ;
32535   }
32536   arg1 = *argp1;
32537   argp2 = (Dali::Actor *)jarg2;
32538   if (!argp2) {
32539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32540     return ;
32541   }
32542   arg2 = *argp2;
32543   {
32544     try {
32545       Dali::DevelActor::LowerBelow(arg1,arg2);
32546     } catch (std::out_of_range& e) {
32547       {
32548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32549       };
32550     } catch (std::exception& e) {
32551       {
32552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32553       };
32554     } catch (...) {
32555       {
32556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32557       };
32558     }
32559   }
32560 }
32561
32562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32563   void * jresult ;
32564   Dali::Actor arg1 ;
32565   Dali::Actor *argp1 ;
32566   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32567
32568   argp1 = (Dali::Actor *)jarg1;
32569   if (!argp1) {
32570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32571     return 0;
32572   }
32573   arg1 = *argp1;
32574   {
32575     try {
32576       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32577     } catch (std::out_of_range& e) {
32578       {
32579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32580       };
32581     } catch (std::exception& e) {
32582       {
32583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32584       };
32585     } catch (...) {
32586       {
32587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32588       };
32589     }
32590   }
32591   jresult = (void *)result;
32592   return jresult;
32593 }
32594
32595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
32596   int jresult ;
32597   int result;
32598
32599   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
32600   jresult = (int)result;
32601   return jresult;
32602 }
32603
32604
32605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
32606   int jresult ;
32607   int result;
32608
32609   result = (int)Dali::Layer::Property::CLIPPING_BOX;
32610   jresult = (int)result;
32611   return jresult;
32612 }
32613
32614
32615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
32616   int jresult ;
32617   int result;
32618
32619   result = (int)Dali::Layer::Property::BEHAVIOR;
32620   jresult = (int)result;
32621   return jresult;
32622 }
32623
32624
32625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
32626   void * jresult ;
32627   Dali::Layer::Property *result = 0 ;
32628
32629   {
32630     try {
32631       result = (Dali::Layer::Property *)new Dali::Layer::Property();
32632     } catch (std::out_of_range& e) {
32633       {
32634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32635       };
32636     } catch (std::exception& e) {
32637       {
32638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32639       };
32640     } catch (...) {
32641       {
32642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32643       };
32644     }
32645   }
32646   jresult = (void *)result;
32647   return jresult;
32648 }
32649
32650
32651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
32652   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
32653
32654   arg1 = (Dali::Layer::Property *)jarg1;
32655   {
32656     try {
32657       delete arg1;
32658     } catch (std::out_of_range& e) {
32659       {
32660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32661       };
32662     } catch (std::exception& e) {
32663       {
32664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32665       };
32666     } catch (...) {
32667       {
32668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32669       };
32670     }
32671   }
32672 }
32673
32674
32675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
32676   void * jresult ;
32677   Dali::Layer *result = 0 ;
32678
32679   {
32680     try {
32681       result = (Dali::Layer *)new Dali::Layer();
32682     } catch (std::out_of_range& e) {
32683       {
32684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32685       };
32686     } catch (std::exception& e) {
32687       {
32688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32689       };
32690     } catch (...) {
32691       {
32692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32693       };
32694     }
32695   }
32696   jresult = (void *)result;
32697   return jresult;
32698 }
32699
32700
32701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
32702   void * jresult ;
32703   Dali::Layer result;
32704
32705   {
32706     try {
32707       result = Dali::Layer::New();
32708     } catch (std::out_of_range& e) {
32709       {
32710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32711       };
32712     } catch (std::exception& e) {
32713       {
32714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32715       };
32716     } catch (...) {
32717       {
32718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32719       };
32720     }
32721   }
32722   jresult = new Dali::Layer((const Dali::Layer &)result);
32723   return jresult;
32724 }
32725
32726
32727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
32728   void * jresult ;
32729   Dali::BaseHandle arg1 ;
32730   Dali::BaseHandle *argp1 ;
32731   Dali::Layer result;
32732
32733   argp1 = (Dali::BaseHandle *)jarg1;
32734   if (!argp1) {
32735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
32736     return 0;
32737   }
32738   arg1 = *argp1;
32739   {
32740     try {
32741       result = Dali::Layer::DownCast(arg1);
32742     } catch (std::out_of_range& e) {
32743       {
32744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32745       };
32746     } catch (std::exception& e) {
32747       {
32748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32749       };
32750     } catch (...) {
32751       {
32752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32753       };
32754     }
32755   }
32756   jresult = new Dali::Layer((const Dali::Layer &)result);
32757   return jresult;
32758 }
32759
32760
32761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
32762   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32763
32764   arg1 = (Dali::Layer *)jarg1;
32765   {
32766     try {
32767       delete arg1;
32768     } catch (std::out_of_range& e) {
32769       {
32770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32771       };
32772     } catch (std::exception& e) {
32773       {
32774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32775       };
32776     } catch (...) {
32777       {
32778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32779       };
32780     }
32781   }
32782 }
32783
32784
32785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
32786   void * jresult ;
32787   Dali::Layer *arg1 = 0 ;
32788   Dali::Layer *result = 0 ;
32789
32790   arg1 = (Dali::Layer *)jarg1;
32791   if (!arg1) {
32792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32793     return 0;
32794   }
32795   {
32796     try {
32797       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
32798     } catch (std::out_of_range& e) {
32799       {
32800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32801       };
32802     } catch (std::exception& e) {
32803       {
32804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32805       };
32806     } catch (...) {
32807       {
32808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32809       };
32810     }
32811   }
32812   jresult = (void *)result;
32813   return jresult;
32814 }
32815
32816
32817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
32818   void * jresult ;
32819   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32820   Dali::Layer *arg2 = 0 ;
32821   Dali::Layer *result = 0 ;
32822
32823   arg1 = (Dali::Layer *)jarg1;
32824   arg2 = (Dali::Layer *)jarg2;
32825   if (!arg2) {
32826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32827     return 0;
32828   }
32829   {
32830     try {
32831       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
32832     } catch (std::out_of_range& e) {
32833       {
32834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32835       };
32836     } catch (std::exception& e) {
32837       {
32838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32839       };
32840     } catch (...) {
32841       {
32842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32843       };
32844     }
32845   }
32846   jresult = (void *)result;
32847   return jresult;
32848 }
32849
32850
32851 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
32852   unsigned int jresult ;
32853   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32854   unsigned int result;
32855
32856   arg1 = (Dali::Layer *)jarg1;
32857   {
32858     try {
32859       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
32860     } catch (std::out_of_range& e) {
32861       {
32862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32863       };
32864     } catch (std::exception& e) {
32865       {
32866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32867       };
32868     } catch (...) {
32869       {
32870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32871       };
32872     }
32873   }
32874   jresult = result;
32875   return jresult;
32876 }
32877
32878
32879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
32880   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32881
32882   arg1 = (Dali::Layer *)jarg1;
32883   {
32884     try {
32885       (arg1)->Raise();
32886     } catch (std::out_of_range& e) {
32887       {
32888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32889       };
32890     } catch (std::exception& e) {
32891       {
32892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32893       };
32894     } catch (...) {
32895       {
32896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32897       };
32898     }
32899   }
32900 }
32901
32902
32903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
32904   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32905
32906   arg1 = (Dali::Layer *)jarg1;
32907   {
32908     try {
32909       (arg1)->Lower();
32910     } catch (std::out_of_range& e) {
32911       {
32912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32913       };
32914     } catch (std::exception& e) {
32915       {
32916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32917       };
32918     } catch (...) {
32919       {
32920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32921       };
32922     }
32923   }
32924 }
32925
32926
32927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
32928   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32929   Dali::Layer arg2 ;
32930   Dali::Layer *argp2 ;
32931
32932   arg1 = (Dali::Layer *)jarg1;
32933   argp2 = (Dali::Layer *)jarg2;
32934   if (!argp2) {
32935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32936     return ;
32937   }
32938   arg2 = *argp2;
32939   {
32940     try {
32941       (arg1)->RaiseAbove(arg2);
32942     } catch (std::out_of_range& e) {
32943       {
32944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32945       };
32946     } catch (std::exception& e) {
32947       {
32948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32949       };
32950     } catch (...) {
32951       {
32952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32953       };
32954     }
32955   }
32956 }
32957
32958
32959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
32960   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32961   Dali::Layer arg2 ;
32962   Dali::Layer *argp2 ;
32963
32964   arg1 = (Dali::Layer *)jarg1;
32965   argp2 = (Dali::Layer *)jarg2;
32966   if (!argp2) {
32967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32968     return ;
32969   }
32970   arg2 = *argp2;
32971   {
32972     try {
32973       (arg1)->LowerBelow(arg2);
32974     } catch (std::out_of_range& e) {
32975       {
32976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32977       };
32978     } catch (std::exception& e) {
32979       {
32980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32981       };
32982     } catch (...) {
32983       {
32984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32985       };
32986     }
32987   }
32988 }
32989
32990
32991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
32992   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32993
32994   arg1 = (Dali::Layer *)jarg1;
32995   {
32996     try {
32997       (arg1)->RaiseToTop();
32998     } catch (std::out_of_range& e) {
32999       {
33000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33001       };
33002     } catch (std::exception& e) {
33003       {
33004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33005       };
33006     } catch (...) {
33007       {
33008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33009       };
33010     }
33011   }
33012 }
33013
33014
33015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
33016   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33017
33018   arg1 = (Dali::Layer *)jarg1;
33019   {
33020     try {
33021       (arg1)->LowerToBottom();
33022     } catch (std::out_of_range& e) {
33023       {
33024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33025       };
33026     } catch (std::exception& e) {
33027       {
33028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33029       };
33030     } catch (...) {
33031       {
33032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33033       };
33034     }
33035   }
33036 }
33037
33038
33039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
33040   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33041   Dali::Layer arg2 ;
33042   Dali::Layer *argp2 ;
33043
33044   arg1 = (Dali::Layer *)jarg1;
33045   argp2 = (Dali::Layer *)jarg2;
33046   if (!argp2) {
33047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
33048     return ;
33049   }
33050   arg2 = *argp2;
33051   {
33052     try {
33053       (arg1)->MoveAbove(arg2);
33054     } catch (std::out_of_range& e) {
33055       {
33056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33057       };
33058     } catch (std::exception& e) {
33059       {
33060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33061       };
33062     } catch (...) {
33063       {
33064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33065       };
33066     }
33067   }
33068 }
33069
33070
33071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
33072   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33073   Dali::Layer arg2 ;
33074   Dali::Layer *argp2 ;
33075
33076   arg1 = (Dali::Layer *)jarg1;
33077   argp2 = (Dali::Layer *)jarg2;
33078   if (!argp2) {
33079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
33080     return ;
33081   }
33082   arg2 = *argp2;
33083   {
33084     try {
33085       (arg1)->MoveBelow(arg2);
33086     } catch (std::out_of_range& e) {
33087       {
33088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33089       };
33090     } catch (std::exception& e) {
33091       {
33092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33093       };
33094     } catch (...) {
33095       {
33096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33097       };
33098     }
33099   }
33100 }
33101
33102
33103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
33104   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33105   Dali::Layer::Behavior arg2 ;
33106
33107   arg1 = (Dali::Layer *)jarg1;
33108   arg2 = (Dali::Layer::Behavior)jarg2;
33109   {
33110     try {
33111       (arg1)->SetBehavior(arg2);
33112     } catch (std::out_of_range& e) {
33113       {
33114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33115       };
33116     } catch (std::exception& e) {
33117       {
33118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33119       };
33120     } catch (...) {
33121       {
33122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33123       };
33124     }
33125   }
33126 }
33127
33128
33129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
33130   int jresult ;
33131   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33132   Dali::Layer::Behavior result;
33133
33134   arg1 = (Dali::Layer *)jarg1;
33135   {
33136     try {
33137       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
33138     } catch (std::out_of_range& e) {
33139       {
33140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33141       };
33142     } catch (std::exception& e) {
33143       {
33144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33145       };
33146     } catch (...) {
33147       {
33148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33149       };
33150     }
33151   }
33152   jresult = (int)result;
33153   return jresult;
33154 }
33155
33156
33157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
33158   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33159   bool arg2 ;
33160
33161   arg1 = (Dali::Layer *)jarg1;
33162   arg2 = jarg2 ? true : false;
33163   {
33164     try {
33165       (arg1)->SetClipping(arg2);
33166     } catch (std::out_of_range& e) {
33167       {
33168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33169       };
33170     } catch (std::exception& e) {
33171       {
33172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33173       };
33174     } catch (...) {
33175       {
33176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33177       };
33178     }
33179   }
33180 }
33181
33182
33183 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
33184   unsigned int jresult ;
33185   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33186   bool result;
33187
33188   arg1 = (Dali::Layer *)jarg1;
33189   {
33190     try {
33191       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
33192     } catch (std::out_of_range& e) {
33193       {
33194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33195       };
33196     } catch (std::exception& e) {
33197       {
33198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33199       };
33200     } catch (...) {
33201       {
33202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33203       };
33204     }
33205   }
33206   jresult = result;
33207   return jresult;
33208 }
33209
33210
33211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
33212   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33213   int arg2 ;
33214   int arg3 ;
33215   int arg4 ;
33216   int arg5 ;
33217
33218   arg1 = (Dali::Layer *)jarg1;
33219   arg2 = (int)jarg2;
33220   arg3 = (int)jarg3;
33221   arg4 = (int)jarg4;
33222   arg5 = (int)jarg5;
33223   {
33224     try {
33225       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
33226     } catch (std::out_of_range& e) {
33227       {
33228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33229       };
33230     } catch (std::exception& e) {
33231       {
33232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33233       };
33234     } catch (...) {
33235       {
33236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33237       };
33238     }
33239   }
33240 }
33241
33242
33243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
33244   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33245   Dali::ClippingBox arg2 ;
33246   Dali::ClippingBox *argp2 ;
33247
33248   arg1 = (Dali::Layer *)jarg1;
33249   argp2 = (Dali::ClippingBox *)jarg2;
33250   if (!argp2) {
33251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
33252     return ;
33253   }
33254   arg2 = *argp2;
33255   {
33256     try {
33257       (arg1)->SetClippingBox(arg2);
33258     } catch (std::out_of_range& e) {
33259       {
33260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33261       };
33262     } catch (std::exception& e) {
33263       {
33264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33265       };
33266     } catch (...) {
33267       {
33268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33269       };
33270     }
33271   }
33272 }
33273
33274
33275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
33276   void * jresult ;
33277   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33278   Dali::ClippingBox result;
33279
33280   arg1 = (Dali::Layer *)jarg1;
33281   {
33282     try {
33283       result = ((Dali::Layer const *)arg1)->GetClippingBox();
33284     } catch (std::out_of_range& e) {
33285       {
33286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33287       };
33288     } catch (std::exception& e) {
33289       {
33290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33291       };
33292     } catch (...) {
33293       {
33294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33295       };
33296     }
33297   }
33298   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
33299   return jresult;
33300 }
33301
33302
33303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
33304   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33305   bool arg2 ;
33306
33307   arg1 = (Dali::Layer *)jarg1;
33308   arg2 = jarg2 ? true : false;
33309   {
33310     try {
33311       (arg1)->SetDepthTestDisabled(arg2);
33312     } catch (std::out_of_range& e) {
33313       {
33314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33315       };
33316     } catch (std::exception& e) {
33317       {
33318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33319       };
33320     } catch (...) {
33321       {
33322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33323       };
33324     }
33325   }
33326 }
33327
33328
33329 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
33330   unsigned int jresult ;
33331   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33332   bool result;
33333
33334   arg1 = (Dali::Layer *)jarg1;
33335   {
33336     try {
33337       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
33338     } catch (std::out_of_range& e) {
33339       {
33340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33341       };
33342     } catch (std::exception& e) {
33343       {
33344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33345       };
33346     } catch (...) {
33347       {
33348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33349       };
33350     }
33351   }
33352   jresult = result;
33353   return jresult;
33354 }
33355
33356
33357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
33358   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33359   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
33360
33361   arg1 = (Dali::Layer *)jarg1;
33362   arg2 = (Dali::Layer::SortFunctionType)jarg2;
33363   {
33364     try {
33365       (arg1)->SetSortFunction(arg2);
33366     } catch (std::out_of_range& e) {
33367       {
33368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33369       };
33370     } catch (std::exception& e) {
33371       {
33372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33373       };
33374     } catch (...) {
33375       {
33376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33377       };
33378     }
33379   }
33380 }
33381
33382
33383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
33384   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33385   bool arg2 ;
33386
33387   arg1 = (Dali::Layer *)jarg1;
33388   arg2 = jarg2 ? true : false;
33389   {
33390     try {
33391       (arg1)->SetTouchConsumed(arg2);
33392     } catch (std::out_of_range& e) {
33393       {
33394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33395       };
33396     } catch (std::exception& e) {
33397       {
33398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33399       };
33400     } catch (...) {
33401       {
33402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33403       };
33404     }
33405   }
33406 }
33407
33408
33409 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
33410   unsigned int jresult ;
33411   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33412   bool result;
33413
33414   arg1 = (Dali::Layer *)jarg1;
33415   {
33416     try {
33417       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
33418     } catch (std::out_of_range& e) {
33419       {
33420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33421       };
33422     } catch (std::exception& e) {
33423       {
33424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33425       };
33426     } catch (...) {
33427       {
33428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33429       };
33430     }
33431   }
33432   jresult = result;
33433   return jresult;
33434 }
33435
33436
33437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
33438   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33439   bool arg2 ;
33440
33441   arg1 = (Dali::Layer *)jarg1;
33442   arg2 = jarg2 ? true : false;
33443   {
33444     try {
33445       (arg1)->SetHoverConsumed(arg2);
33446     } catch (std::out_of_range& e) {
33447       {
33448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33449       };
33450     } catch (std::exception& e) {
33451       {
33452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33453       };
33454     } catch (...) {
33455       {
33456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33457       };
33458     }
33459   }
33460 }
33461
33462
33463 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
33464   unsigned int jresult ;
33465   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33466   bool result;
33467
33468   arg1 = (Dali::Layer *)jarg1;
33469   {
33470     try {
33471       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
33472     } catch (std::out_of_range& e) {
33473       {
33474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33475       };
33476     } catch (std::exception& e) {
33477       {
33478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33479       };
33480     } catch (...) {
33481       {
33482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33483       };
33484     }
33485   }
33486   jresult = result;
33487   return jresult;
33488 }
33489
33490
33491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
33492   void * jresult ;
33493   Dali::Vector4 *result = 0 ;
33494
33495   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
33496   jresult = (void *)result;
33497   return jresult;
33498 }
33499
33500
33501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
33502   void * jresult ;
33503   Dali::Vector4 *result = 0 ;
33504
33505   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
33506   jresult = (void *)result;
33507   return jresult;
33508 }
33509
33510
33511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
33512   void * jresult ;
33513   Dali::Stage *result = 0 ;
33514
33515   {
33516     try {
33517       result = (Dali::Stage *)new Dali::Stage();
33518     } catch (std::out_of_range& e) {
33519       {
33520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33521       };
33522     } catch (std::exception& e) {
33523       {
33524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33525       };
33526     } catch (...) {
33527       {
33528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33529       };
33530     }
33531   }
33532   jresult = (void *)result;
33533   return jresult;
33534 }
33535
33536
33537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
33538   void * jresult ;
33539   Dali::Stage result;
33540
33541   {
33542     try {
33543       result = Dali::Stage::GetCurrent();
33544     } catch (std::out_of_range& e) {
33545       {
33546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33547       };
33548     } catch (std::exception& e) {
33549       {
33550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33551       };
33552     } catch (...) {
33553       {
33554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33555       };
33556     }
33557   }
33558   jresult = new Dali::Stage((const Dali::Stage &)result);
33559   return jresult;
33560 }
33561
33562
33563 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
33564   unsigned int jresult ;
33565   bool result;
33566
33567   {
33568     try {
33569       result = (bool)Dali::Stage::IsInstalled();
33570     } catch (std::out_of_range& e) {
33571       {
33572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33573       };
33574     } catch (std::exception& e) {
33575       {
33576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33577       };
33578     } catch (...) {
33579       {
33580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33581       };
33582     }
33583   }
33584   jresult = result;
33585   return jresult;
33586 }
33587
33588
33589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
33590   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33591
33592   arg1 = (Dali::Stage *)jarg1;
33593   {
33594     try {
33595       delete arg1;
33596     } catch (std::out_of_range& e) {
33597       {
33598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33599       };
33600     } catch (std::exception& e) {
33601       {
33602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33603       };
33604     } catch (...) {
33605       {
33606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33607       };
33608     }
33609   }
33610 }
33611
33612
33613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
33614   void * jresult ;
33615   Dali::Stage *arg1 = 0 ;
33616   Dali::Stage *result = 0 ;
33617
33618   arg1 = (Dali::Stage *)jarg1;
33619   if (!arg1) {
33620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33621     return 0;
33622   }
33623   {
33624     try {
33625       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
33626     } catch (std::out_of_range& e) {
33627       {
33628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33629       };
33630     } catch (std::exception& e) {
33631       {
33632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33633       };
33634     } catch (...) {
33635       {
33636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33637       };
33638     }
33639   }
33640   jresult = (void *)result;
33641   return jresult;
33642 }
33643
33644
33645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
33646   void * jresult ;
33647   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33648   Dali::Stage *arg2 = 0 ;
33649   Dali::Stage *result = 0 ;
33650
33651   arg1 = (Dali::Stage *)jarg1;
33652   arg2 = (Dali::Stage *)jarg2;
33653   if (!arg2) {
33654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33655     return 0;
33656   }
33657   {
33658     try {
33659       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
33660     } catch (std::out_of_range& e) {
33661       {
33662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33663       };
33664     } catch (std::exception& e) {
33665       {
33666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33667       };
33668     } catch (...) {
33669       {
33670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33671       };
33672     }
33673   }
33674   jresult = (void *)result;
33675   return jresult;
33676 }
33677
33678
33679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
33680   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33681   Dali::Actor *arg2 = 0 ;
33682
33683   arg1 = (Dali::Stage *)jarg1;
33684   arg2 = (Dali::Actor *)jarg2;
33685   if (!arg2) {
33686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33687     return ;
33688   }
33689   {
33690     try {
33691       (arg1)->Add(*arg2);
33692     } catch (std::out_of_range& e) {
33693       {
33694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33695       };
33696     } catch (std::exception& e) {
33697       {
33698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33699       };
33700     } catch (...) {
33701       {
33702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33703       };
33704     }
33705   }
33706 }
33707
33708
33709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
33710   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33711   Dali::Actor *arg2 = 0 ;
33712
33713   arg1 = (Dali::Stage *)jarg1;
33714   arg2 = (Dali::Actor *)jarg2;
33715   if (!arg2) {
33716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33717     return ;
33718   }
33719   {
33720     try {
33721       (arg1)->Remove(*arg2);
33722     } catch (std::out_of_range& e) {
33723       {
33724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33725       };
33726     } catch (std::exception& e) {
33727       {
33728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33729       };
33730     } catch (...) {
33731       {
33732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33733       };
33734     }
33735   }
33736 }
33737
33738
33739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
33740   void * jresult ;
33741   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33742   Dali::Vector2 result;
33743
33744   arg1 = (Dali::Stage *)jarg1;
33745   {
33746     try {
33747       result = ((Dali::Stage const *)arg1)->GetSize();
33748     } catch (std::out_of_range& e) {
33749       {
33750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33751       };
33752     } catch (std::exception& e) {
33753       {
33754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33755       };
33756     } catch (...) {
33757       {
33758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33759       };
33760     }
33761   }
33762   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33763   return jresult;
33764 }
33765
33766
33767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
33768   void * jresult ;
33769   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33770   Dali::RenderTaskList result;
33771
33772   arg1 = (Dali::Stage *)jarg1;
33773   {
33774     try {
33775       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
33776     } catch (std::out_of_range& e) {
33777       {
33778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33779       };
33780     } catch (std::exception& e) {
33781       {
33782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33783       };
33784     } catch (...) {
33785       {
33786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33787       };
33788     }
33789   }
33790   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
33791   return jresult;
33792 }
33793
33794
33795 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
33796   unsigned int jresult ;
33797   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33798   unsigned int result;
33799
33800   arg1 = (Dali::Stage *)jarg1;
33801   {
33802     try {
33803       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
33804     } catch (std::out_of_range& e) {
33805       {
33806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33807       };
33808     } catch (std::exception& e) {
33809       {
33810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33811       };
33812     } catch (...) {
33813       {
33814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33815       };
33816     }
33817   }
33818   jresult = result;
33819   return jresult;
33820 }
33821
33822
33823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
33824   void * jresult ;
33825   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33826   unsigned int arg2 ;
33827   Dali::Layer result;
33828
33829   arg1 = (Dali::Stage *)jarg1;
33830   arg2 = (unsigned int)jarg2;
33831   {
33832     try {
33833       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
33834     } catch (std::out_of_range& e) {
33835       {
33836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33837       };
33838     } catch (std::exception& e) {
33839       {
33840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33841       };
33842     } catch (...) {
33843       {
33844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33845       };
33846     }
33847   }
33848   jresult = new Dali::Layer((const Dali::Layer &)result);
33849   return jresult;
33850 }
33851
33852
33853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
33854   void * jresult ;
33855   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33856   Dali::Layer result;
33857
33858   arg1 = (Dali::Stage *)jarg1;
33859   {
33860     try {
33861       result = ((Dali::Stage const *)arg1)->GetRootLayer();
33862     } catch (std::out_of_range& e) {
33863       {
33864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33865       };
33866     } catch (std::exception& e) {
33867       {
33868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33869       };
33870     } catch (...) {
33871       {
33872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33873       };
33874     }
33875   }
33876   jresult = new Dali::Layer((const Dali::Layer &)result);
33877   return jresult;
33878 }
33879
33880
33881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
33882   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33883   Dali::Vector4 arg2 ;
33884   Dali::Vector4 *argp2 ;
33885
33886   arg1 = (Dali::Stage *)jarg1;
33887   argp2 = (Dali::Vector4 *)jarg2;
33888   if (!argp2) {
33889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
33890     return ;
33891   }
33892   arg2 = *argp2;
33893   {
33894     try {
33895       (arg1)->SetBackgroundColor(arg2);
33896     } catch (std::out_of_range& e) {
33897       {
33898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33899       };
33900     } catch (std::exception& e) {
33901       {
33902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33903       };
33904     } catch (...) {
33905       {
33906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33907       };
33908     }
33909   }
33910 }
33911
33912
33913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
33914   void * jresult ;
33915   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33916   Dali::Vector4 result;
33917
33918   arg1 = (Dali::Stage *)jarg1;
33919   {
33920     try {
33921       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
33922     } catch (std::out_of_range& e) {
33923       {
33924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33925       };
33926     } catch (std::exception& e) {
33927       {
33928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33929       };
33930     } catch (...) {
33931       {
33932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33933       };
33934     }
33935   }
33936   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
33937   return jresult;
33938 }
33939
33940
33941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
33942   void * jresult ;
33943   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33944   Dali::Vector2 result;
33945
33946   arg1 = (Dali::Stage *)jarg1;
33947   {
33948     try {
33949       result = ((Dali::Stage const *)arg1)->GetDpi();
33950     } catch (std::out_of_range& e) {
33951       {
33952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33953       };
33954     } catch (std::exception& e) {
33955       {
33956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33957       };
33958     } catch (...) {
33959       {
33960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33961       };
33962     }
33963   }
33964   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33965   return jresult;
33966 }
33967
33968
33969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
33970   void * jresult ;
33971   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33972   Dali::ObjectRegistry result;
33973
33974   arg1 = (Dali::Stage *)jarg1;
33975   {
33976     try {
33977       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
33978     } catch (std::out_of_range& e) {
33979       {
33980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33981       };
33982     } catch (std::exception& e) {
33983       {
33984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33985       };
33986     } catch (...) {
33987       {
33988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33989       };
33990     }
33991   }
33992   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
33993   return jresult;
33994 }
33995
33996
33997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
33998   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33999   float arg2 ;
34000
34001   arg1 = (Dali::Stage *)jarg1;
34002   arg2 = (float)jarg2;
34003   {
34004     try {
34005       (arg1)->KeepRendering(arg2);
34006     } catch (std::out_of_range& e) {
34007       {
34008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34009       };
34010     } catch (std::exception& e) {
34011       {
34012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34013       };
34014     } catch (...) {
34015       {
34016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34017       };
34018     }
34019   }
34020 }
34021
34022
34023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
34024   void * jresult ;
34025   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34026   Dali::Stage::KeyEventSignalType *result = 0 ;
34027
34028   arg1 = (Dali::Stage *)jarg1;
34029   {
34030     try {
34031       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
34032     } catch (std::out_of_range& e) {
34033       {
34034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34035       };
34036     } catch (std::exception& e) {
34037       {
34038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34039       };
34040     } catch (...) {
34041       {
34042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34043       };
34044     }
34045   }
34046   jresult = (void *)result;
34047   return jresult;
34048 }
34049
34050
34051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
34052   void * jresult ;
34053   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34054   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
34055
34056   arg1 = (Dali::Stage *)jarg1;
34057   {
34058     try {
34059       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
34060     } catch (std::out_of_range& e) {
34061       {
34062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34063       };
34064     } catch (std::exception& e) {
34065       {
34066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34067       };
34068     } catch (...) {
34069       {
34070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34071       };
34072     }
34073   }
34074   jresult = (void *)result;
34075   return jresult;
34076 }
34077
34078
34079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
34080   void * jresult ;
34081   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34082   Dali::Stage::TouchSignalType *result = 0 ;
34083
34084   arg1 = (Dali::Stage *)jarg1;
34085   {
34086     try {
34087       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
34088     } catch (std::out_of_range& e) {
34089       {
34090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34091       };
34092     } catch (std::exception& e) {
34093       {
34094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34095       };
34096     } catch (...) {
34097       {
34098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34099       };
34100     }
34101   }
34102   jresult = (void *)result;
34103   return jresult;
34104 }
34105
34106
34107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
34108   void * jresult ;
34109   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34110   Dali::Stage::WheelEventSignalType *result = 0 ;
34111
34112   arg1 = (Dali::Stage *)jarg1;
34113   {
34114     try {
34115       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
34116     } catch (std::out_of_range& e) {
34117       {
34118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34119       };
34120     } catch (std::exception& e) {
34121       {
34122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34123       };
34124     } catch (...) {
34125       {
34126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34127       };
34128     }
34129   }
34130   jresult = (void *)result;
34131   return jresult;
34132 }
34133
34134
34135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
34136   void * jresult ;
34137   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34138   Dali::Stage::ContextStatusSignal *result = 0 ;
34139
34140   arg1 = (Dali::Stage *)jarg1;
34141   {
34142     try {
34143       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
34144     } catch (std::out_of_range& e) {
34145       {
34146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34147       };
34148     } catch (std::exception& e) {
34149       {
34150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34151       };
34152     } catch (...) {
34153       {
34154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34155       };
34156     }
34157   }
34158   jresult = (void *)result;
34159   return jresult;
34160 }
34161
34162
34163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
34164   void * jresult ;
34165   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34166   Dali::Stage::ContextStatusSignal *result = 0 ;
34167
34168   arg1 = (Dali::Stage *)jarg1;
34169   {
34170     try {
34171       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
34172     } catch (std::out_of_range& e) {
34173       {
34174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34175       };
34176     } catch (std::exception& e) {
34177       {
34178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34179       };
34180     } catch (...) {
34181       {
34182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34183       };
34184     }
34185   }
34186   jresult = (void *)result;
34187   return jresult;
34188 }
34189
34190
34191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
34192   void * jresult ;
34193   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34194   Dali::Stage::SceneCreatedSignalType *result = 0 ;
34195
34196   arg1 = (Dali::Stage *)jarg1;
34197   {
34198     try {
34199       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
34200     } catch (std::out_of_range& e) {
34201       {
34202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34203       };
34204     } catch (std::exception& e) {
34205       {
34206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34207       };
34208     } catch (...) {
34209       {
34210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34211       };
34212     }
34213   }
34214   jresult = (void *)result;
34215   return jresult;
34216 }
34217
34218
34219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
34220   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34221
34222   arg1 = (Dali::RelayoutContainer *)jarg1;
34223   {
34224     try {
34225       delete arg1;
34226     } catch (std::out_of_range& e) {
34227       {
34228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34229       };
34230     } catch (std::exception& e) {
34231       {
34232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34233       };
34234     } catch (...) {
34235       {
34236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34237       };
34238     }
34239   }
34240 }
34241
34242
34243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
34244   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34245   Dali::Actor *arg2 = 0 ;
34246   Dali::Vector2 *arg3 = 0 ;
34247
34248   arg1 = (Dali::RelayoutContainer *)jarg1;
34249   arg2 = (Dali::Actor *)jarg2;
34250   if (!arg2) {
34251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34252     return ;
34253   }
34254   arg3 = (Dali::Vector2 *)jarg3;
34255   if (!arg3) {
34256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34257     return ;
34258   }
34259   {
34260     try {
34261       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
34262     } catch (std::out_of_range& e) {
34263       {
34264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34265       };
34266     } catch (std::exception& e) {
34267       {
34268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34269       };
34270     } catch (...) {
34271       {
34272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34273       };
34274     }
34275   }
34276 }
34277
34278
34279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
34280   void * jresult ;
34281   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34282   Dali::CustomActor result;
34283
34284   arg1 = (Dali::CustomActorImpl *)jarg1;
34285   {
34286     try {
34287       result = ((Dali::CustomActorImpl const *)arg1)->Self();
34288     } catch (std::out_of_range& e) {
34289       {
34290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34291       };
34292     } catch (std::exception& e) {
34293       {
34294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34295       };
34296     } catch (...) {
34297       {
34298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34299       };
34300     }
34301   }
34302   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34303   return jresult;
34304 }
34305
34306
34307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
34308   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34309   int arg2 ;
34310
34311   arg1 = (Dali::CustomActorImpl *)jarg1;
34312   arg2 = (int)jarg2;
34313   {
34314     try {
34315       (arg1)->OnStageConnection(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
34333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
34334   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34335
34336   arg1 = (Dali::CustomActorImpl *)jarg1;
34337   {
34338     try {
34339       (arg1)->OnStageDisconnection();
34340     } catch (std::out_of_range& e) {
34341       {
34342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34343       };
34344     } catch (std::exception& e) {
34345       {
34346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34347       };
34348     } catch (...) {
34349       {
34350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34351       };
34352     }
34353   }
34354 }
34355
34356
34357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
34358   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34359   Dali::Actor *arg2 = 0 ;
34360
34361   arg1 = (Dali::CustomActorImpl *)jarg1;
34362   arg2 = (Dali::Actor *)jarg2;
34363   if (!arg2) {
34364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34365     return ;
34366   }
34367   {
34368     try {
34369       (arg1)->OnChildAdd(*arg2);
34370     } catch (std::out_of_range& e) {
34371       {
34372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34373       };
34374     } catch (std::exception& e) {
34375       {
34376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34377       };
34378     } catch (...) {
34379       {
34380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34381       };
34382     }
34383   }
34384 }
34385
34386
34387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
34388   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34389   Dali::Actor *arg2 = 0 ;
34390
34391   arg1 = (Dali::CustomActorImpl *)jarg1;
34392   arg2 = (Dali::Actor *)jarg2;
34393   if (!arg2) {
34394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34395     return ;
34396   }
34397   {
34398     try {
34399       (arg1)->OnChildRemove(*arg2);
34400     } catch (std::out_of_range& e) {
34401       {
34402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34403       };
34404     } catch (std::exception& e) {
34405       {
34406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34407       };
34408     } catch (...) {
34409       {
34410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34411       };
34412     }
34413   }
34414 }
34415
34416
34417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
34418   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34419   Dali::Property::Index arg2 ;
34420   Dali::Property::Value arg3 ;
34421   Dali::Property::Value *argp3 ;
34422
34423   arg1 = (Dali::CustomActorImpl *)jarg1;
34424   arg2 = (Dali::Property::Index)jarg2;
34425   argp3 = (Dali::Property::Value *)jarg3;
34426   if (!argp3) {
34427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
34428     return ;
34429   }
34430   arg3 = *argp3;
34431   {
34432     try {
34433       (arg1)->OnPropertySet(arg2,arg3);
34434     } catch (std::out_of_range& e) {
34435       {
34436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34437       };
34438     } catch (std::exception& e) {
34439       {
34440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34441       };
34442     } catch (...) {
34443       {
34444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34445       };
34446     }
34447   }
34448 }
34449
34450
34451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
34452   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34453   Dali::Vector3 *arg2 = 0 ;
34454
34455   arg1 = (Dali::CustomActorImpl *)jarg1;
34456   arg2 = (Dali::Vector3 *)jarg2;
34457   if (!arg2) {
34458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34459     return ;
34460   }
34461   {
34462     try {
34463       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
34464     } catch (std::out_of_range& e) {
34465       {
34466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34467       };
34468     } catch (std::exception& e) {
34469       {
34470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34471       };
34472     } catch (...) {
34473       {
34474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34475       };
34476     }
34477   }
34478 }
34479
34480
34481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
34482   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34483   Dali::Animation *arg2 = 0 ;
34484   Dali::Vector3 *arg3 = 0 ;
34485
34486   arg1 = (Dali::CustomActorImpl *)jarg1;
34487   arg2 = (Dali::Animation *)jarg2;
34488   if (!arg2) {
34489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
34490     return ;
34491   }
34492   arg3 = (Dali::Vector3 *)jarg3;
34493   if (!arg3) {
34494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34495     return ;
34496   }
34497   {
34498     try {
34499       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
34500     } catch (std::out_of_range& e) {
34501       {
34502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34503       };
34504     } catch (std::exception& e) {
34505       {
34506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34507       };
34508     } catch (...) {
34509       {
34510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34511       };
34512     }
34513   }
34514 }
34515
34516
34517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
34518   unsigned int jresult ;
34519   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34520   Dali::TouchEvent *arg2 = 0 ;
34521   bool result;
34522
34523   arg1 = (Dali::CustomActorImpl *)jarg1;
34524   arg2 = (Dali::TouchEvent *)jarg2;
34525   if (!arg2) {
34526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
34527     return 0;
34528   }
34529   {
34530     try {
34531       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
34532     } catch (std::out_of_range& e) {
34533       {
34534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34535       };
34536     } catch (std::exception& e) {
34537       {
34538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34539       };
34540     } catch (...) {
34541       {
34542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34543       };
34544     }
34545   }
34546   jresult = result;
34547   return jresult;
34548 }
34549
34550
34551 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
34552   unsigned int jresult ;
34553   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34554   Dali::HoverEvent *arg2 = 0 ;
34555   bool result;
34556
34557   arg1 = (Dali::CustomActorImpl *)jarg1;
34558   arg2 = (Dali::HoverEvent *)jarg2;
34559   if (!arg2) {
34560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
34561     return 0;
34562   }
34563   {
34564     try {
34565       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
34566     } catch (std::out_of_range& e) {
34567       {
34568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34569       };
34570     } catch (std::exception& e) {
34571       {
34572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34573       };
34574     } catch (...) {
34575       {
34576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34577       };
34578     }
34579   }
34580   jresult = result;
34581   return jresult;
34582 }
34583
34584
34585 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
34586   unsigned int jresult ;
34587   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34588   Dali::KeyEvent *arg2 = 0 ;
34589   bool result;
34590
34591   arg1 = (Dali::CustomActorImpl *)jarg1;
34592   arg2 = (Dali::KeyEvent *)jarg2;
34593   if (!arg2) {
34594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
34595     return 0;
34596   }
34597   {
34598     try {
34599       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
34600     } catch (std::out_of_range& e) {
34601       {
34602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34603       };
34604     } catch (std::exception& e) {
34605       {
34606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34607       };
34608     } catch (...) {
34609       {
34610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34611       };
34612     }
34613   }
34614   jresult = result;
34615   return jresult;
34616 }
34617
34618
34619 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
34620   unsigned int jresult ;
34621   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34622   Dali::WheelEvent *arg2 = 0 ;
34623   bool result;
34624
34625   arg1 = (Dali::CustomActorImpl *)jarg1;
34626   arg2 = (Dali::WheelEvent *)jarg2;
34627   if (!arg2) {
34628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
34629     return 0;
34630   }
34631   {
34632     try {
34633       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
34634     } catch (std::out_of_range& e) {
34635       {
34636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34637       };
34638     } catch (std::exception& e) {
34639       {
34640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34641       };
34642     } catch (...) {
34643       {
34644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34645       };
34646     }
34647   }
34648   jresult = result;
34649   return jresult;
34650 }
34651
34652
34653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
34654   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34655   Dali::Vector2 *arg2 = 0 ;
34656   Dali::RelayoutContainer *arg3 = 0 ;
34657
34658   arg1 = (Dali::CustomActorImpl *)jarg1;
34659   arg2 = (Dali::Vector2 *)jarg2;
34660   if (!arg2) {
34661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34662     return ;
34663   }
34664   arg3 = (Dali::RelayoutContainer *)jarg3;
34665   if (!arg3) {
34666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
34667     return ;
34668   }
34669   {
34670     try {
34671       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
34672     } catch (std::out_of_range& e) {
34673       {
34674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34675       };
34676     } catch (std::exception& e) {
34677       {
34678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34679       };
34680     } catch (...) {
34681       {
34682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34683       };
34684     }
34685   }
34686 }
34687
34688
34689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
34690   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34691   Dali::ResizePolicy::Type arg2 ;
34692   Dali::Dimension::Type arg3 ;
34693
34694   arg1 = (Dali::CustomActorImpl *)jarg1;
34695   arg2 = (Dali::ResizePolicy::Type)jarg2;
34696   arg3 = (Dali::Dimension::Type)jarg3;
34697   {
34698     try {
34699       (arg1)->OnSetResizePolicy(arg2,arg3);
34700     } catch (std::out_of_range& e) {
34701       {
34702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34703       };
34704     } catch (std::exception& e) {
34705       {
34706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34707       };
34708     } catch (...) {
34709       {
34710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34711       };
34712     }
34713   }
34714 }
34715
34716
34717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
34718   void * jresult ;
34719   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34720   Dali::Vector3 result;
34721
34722   arg1 = (Dali::CustomActorImpl *)jarg1;
34723   {
34724     try {
34725       result = (arg1)->GetNaturalSize();
34726     } catch (std::out_of_range& e) {
34727       {
34728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34729       };
34730     } catch (std::exception& e) {
34731       {
34732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34733       };
34734     } catch (...) {
34735       {
34736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34737       };
34738     }
34739   }
34740   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34741   return jresult;
34742 }
34743
34744
34745 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
34746   float jresult ;
34747   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34748   Dali::Actor *arg2 = 0 ;
34749   Dali::Dimension::Type arg3 ;
34750   float result;
34751
34752   arg1 = (Dali::CustomActorImpl *)jarg1;
34753   arg2 = (Dali::Actor *)jarg2;
34754   if (!arg2) {
34755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34756     return 0;
34757   }
34758   arg3 = (Dali::Dimension::Type)jarg3;
34759   {
34760     try {
34761       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
34762     } catch (std::out_of_range& e) {
34763       {
34764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34765       };
34766     } catch (std::exception& e) {
34767       {
34768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34769       };
34770     } catch (...) {
34771       {
34772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34773       };
34774     }
34775   }
34776   jresult = result;
34777   return jresult;
34778 }
34779
34780
34781 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
34782   float jresult ;
34783   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34784   float arg2 ;
34785   float result;
34786
34787   arg1 = (Dali::CustomActorImpl *)jarg1;
34788   arg2 = (float)jarg2;
34789   {
34790     try {
34791       result = (float)(arg1)->GetHeightForWidth(arg2);
34792     } catch (std::out_of_range& e) {
34793       {
34794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34795       };
34796     } catch (std::exception& e) {
34797       {
34798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34799       };
34800     } catch (...) {
34801       {
34802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34803       };
34804     }
34805   }
34806   jresult = result;
34807   return jresult;
34808 }
34809
34810
34811 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
34812   float jresult ;
34813   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34814   float arg2 ;
34815   float result;
34816
34817   arg1 = (Dali::CustomActorImpl *)jarg1;
34818   arg2 = (float)jarg2;
34819   {
34820     try {
34821       result = (float)(arg1)->GetWidthForHeight(arg2);
34822     } catch (std::out_of_range& e) {
34823       {
34824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34825       };
34826     } catch (std::exception& e) {
34827       {
34828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34829       };
34830     } catch (...) {
34831       {
34832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34833       };
34834     }
34835   }
34836   jresult = result;
34837   return jresult;
34838 }
34839
34840
34841 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
34842   unsigned int jresult ;
34843   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34844   Dali::Dimension::Type arg2 ;
34845   bool result;
34846
34847   arg1 = (Dali::CustomActorImpl *)jarg1;
34848   arg2 = (Dali::Dimension::Type)jarg2;
34849   {
34850     try {
34851       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
34852     } catch (std::out_of_range& e) {
34853       {
34854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34855       };
34856     } catch (std::exception& e) {
34857       {
34858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34859       };
34860     } catch (...) {
34861       {
34862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34863       };
34864     }
34865   }
34866   jresult = result;
34867   return jresult;
34868 }
34869
34870
34871 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
34872   unsigned int jresult ;
34873   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34874   bool result;
34875
34876   arg1 = (Dali::CustomActorImpl *)jarg1;
34877   {
34878     try {
34879       result = (bool)(arg1)->RelayoutDependentOnChildren();
34880     } catch (std::out_of_range& e) {
34881       {
34882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34883       };
34884     } catch (std::exception& e) {
34885       {
34886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34887       };
34888     } catch (...) {
34889       {
34890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34891       };
34892     }
34893   }
34894   jresult = result;
34895   return jresult;
34896 }
34897
34898
34899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
34900   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34901   Dali::Dimension::Type arg2 ;
34902
34903   arg1 = (Dali::CustomActorImpl *)jarg1;
34904   arg2 = (Dali::Dimension::Type)jarg2;
34905   {
34906     try {
34907       (arg1)->OnCalculateRelayoutSize(arg2);
34908     } catch (std::out_of_range& e) {
34909       {
34910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34911       };
34912     } catch (std::exception& e) {
34913       {
34914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34915       };
34916     } catch (...) {
34917       {
34918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34919       };
34920     }
34921   }
34922 }
34923
34924
34925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
34926   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34927   float arg2 ;
34928   Dali::Dimension::Type arg3 ;
34929
34930   arg1 = (Dali::CustomActorImpl *)jarg1;
34931   arg2 = (float)jarg2;
34932   arg3 = (Dali::Dimension::Type)jarg3;
34933   {
34934     try {
34935       (arg1)->OnLayoutNegotiated(arg2,arg3);
34936     } catch (std::out_of_range& e) {
34937       {
34938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34939       };
34940     } catch (std::exception& e) {
34941       {
34942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34943       };
34944     } catch (...) {
34945       {
34946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34947       };
34948     }
34949   }
34950 }
34951
34952
34953 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
34954   unsigned int jresult ;
34955   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34956   bool result;
34957
34958   arg1 = (Dali::CustomActorImpl *)jarg1;
34959   {
34960     try {
34961       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
34962     } catch (std::out_of_range& e) {
34963       {
34964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34965       };
34966     } catch (std::exception& e) {
34967       {
34968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34969       };
34970     } catch (...) {
34971       {
34972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34973       };
34974     }
34975   }
34976   jresult = result;
34977   return jresult;
34978 }
34979
34980
34981 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
34982   unsigned int jresult ;
34983   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34984   bool result;
34985
34986   arg1 = (Dali::CustomActorImpl *)jarg1;
34987   {
34988     try {
34989       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
34990     } catch (std::out_of_range& e) {
34991       {
34992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34993       };
34994     } catch (std::exception& e) {
34995       {
34996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34997       };
34998     } catch (...) {
34999       {
35000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35001       };
35002     }
35003   }
35004   jresult = result;
35005   return jresult;
35006 }
35007
35008
35009 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
35010   unsigned int jresult ;
35011   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
35012   bool result;
35013
35014   arg1 = (Dali::CustomActorImpl *)jarg1;
35015   {
35016     try {
35017       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
35018     } catch (std::out_of_range& e) {
35019       {
35020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35021       };
35022     } catch (std::exception& e) {
35023       {
35024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35025       };
35026     } catch (...) {
35027       {
35028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35029       };
35030     }
35031   }
35032   jresult = result;
35033   return jresult;
35034 }
35035
35036
35037 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
35038   unsigned int jresult ;
35039   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
35040   bool result;
35041
35042   arg1 = (Dali::CustomActorImpl *)jarg1;
35043   {
35044     try {
35045       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
35046     } catch (std::out_of_range& e) {
35047       {
35048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35049       };
35050     } catch (std::exception& e) {
35051       {
35052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35053       };
35054     } catch (...) {
35055       {
35056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35057       };
35058     }
35059   }
35060   jresult = result;
35061   return jresult;
35062 }
35063
35064
35065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
35066   void * jresult ;
35067   Dali::CustomActor *result = 0 ;
35068
35069   {
35070     try {
35071       result = (Dali::CustomActor *)new Dali::CustomActor();
35072     } catch (std::out_of_range& e) {
35073       {
35074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35075       };
35076     } catch (std::exception& e) {
35077       {
35078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35079       };
35080     } catch (...) {
35081       {
35082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35083       };
35084     }
35085   }
35086   jresult = (void *)result;
35087   return jresult;
35088 }
35089
35090
35091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
35092   void * jresult ;
35093   Dali::BaseHandle arg1 ;
35094   Dali::BaseHandle *argp1 ;
35095   Dali::CustomActor result;
35096
35097   argp1 = (Dali::BaseHandle *)jarg1;
35098   if (!argp1) {
35099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35100     return 0;
35101   }
35102   arg1 = *argp1;
35103   {
35104     try {
35105       result = Dali::CustomActor::DownCast(arg1);
35106     } catch (std::out_of_range& e) {
35107       {
35108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35109       };
35110     } catch (std::exception& e) {
35111       {
35112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35113       };
35114     } catch (...) {
35115       {
35116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35117       };
35118     }
35119   }
35120   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
35121   return jresult;
35122 }
35123
35124
35125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
35126   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35127
35128   arg1 = (Dali::CustomActor *)jarg1;
35129   {
35130     try {
35131       delete arg1;
35132     } catch (std::out_of_range& e) {
35133       {
35134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35135       };
35136     } catch (std::exception& e) {
35137       {
35138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35139       };
35140     } catch (...) {
35141       {
35142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35143       };
35144     }
35145   }
35146 }
35147
35148
35149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
35150   void * jresult ;
35151   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35152   Dali::CustomActorImpl *result = 0 ;
35153
35154   arg1 = (Dali::CustomActor *)jarg1;
35155   {
35156     try {
35157       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
35158     } catch (std::out_of_range& e) {
35159       {
35160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35161       };
35162     } catch (std::exception& e) {
35163       {
35164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35165       };
35166     } catch (...) {
35167       {
35168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35169       };
35170     }
35171   }
35172   jresult = (void *)result;
35173   return jresult;
35174 }
35175
35176
35177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
35178   void * jresult ;
35179   Dali::CustomActorImpl *arg1 = 0 ;
35180   Dali::CustomActor *result = 0 ;
35181
35182   arg1 = (Dali::CustomActorImpl *)jarg1;
35183   if (!arg1) {
35184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
35185     return 0;
35186   }
35187   {
35188     try {
35189       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
35190     } catch (std::out_of_range& e) {
35191       {
35192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35193       };
35194     } catch (std::exception& e) {
35195       {
35196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35197       };
35198     } catch (...) {
35199       {
35200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35201       };
35202     }
35203   }
35204   jresult = (void *)result;
35205   return jresult;
35206 }
35207
35208
35209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
35210   void * jresult ;
35211   Dali::CustomActor *arg1 = 0 ;
35212   Dali::CustomActor *result = 0 ;
35213
35214   arg1 = (Dali::CustomActor *)jarg1;
35215   if (!arg1) {
35216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35217     return 0;
35218   }
35219   {
35220     try {
35221       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
35222     } catch (std::out_of_range& e) {
35223       {
35224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35225       };
35226     } catch (std::exception& e) {
35227       {
35228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35229       };
35230     } catch (...) {
35231       {
35232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35233       };
35234     }
35235   }
35236   jresult = (void *)result;
35237   return jresult;
35238 }
35239
35240
35241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
35242   void * jresult ;
35243   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35244   Dali::CustomActor *arg2 = 0 ;
35245   Dali::CustomActor *result = 0 ;
35246
35247   arg1 = (Dali::CustomActor *)jarg1;
35248   arg2 = (Dali::CustomActor *)jarg2;
35249   if (!arg2) {
35250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35251     return 0;
35252   }
35253   {
35254     try {
35255       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
35256     } catch (std::out_of_range& e) {
35257       {
35258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35259       };
35260     } catch (std::exception& e) {
35261       {
35262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35263       };
35264     } catch (...) {
35265       {
35266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35267       };
35268     }
35269   }
35270   jresult = (void *)result;
35271   return jresult;
35272 }
35273
35274
35275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
35276   int jresult ;
35277   int result;
35278
35279   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
35280   jresult = (int)result;
35281   return jresult;
35282 }
35283
35284
35285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
35286   int jresult ;
35287   int result;
35288
35289   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
35290   jresult = (int)result;
35291   return jresult;
35292 }
35293
35294
35295 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
35296   int jresult ;
35297   int result;
35298
35299   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
35300   jresult = (int)result;
35301   return jresult;
35302 }
35303
35304
35305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
35306   int jresult ;
35307   int result;
35308
35309   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
35310   jresult = (int)result;
35311   return jresult;
35312 }
35313
35314
35315 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
35316   int jresult ;
35317   int result;
35318
35319   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
35320   jresult = (int)result;
35321   return jresult;
35322 }
35323
35324
35325 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
35326   int jresult ;
35327   int result;
35328
35329   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
35330   jresult = (int)result;
35331   return jresult;
35332 }
35333
35334
35335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
35336   int jresult ;
35337   int result;
35338
35339   result = (int)Dali::PanGestureDetector::Property::PANNING;
35340   jresult = (int)result;
35341   return jresult;
35342 }
35343
35344
35345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
35346   void * jresult ;
35347   Dali::PanGestureDetector::Property *result = 0 ;
35348
35349   {
35350     try {
35351       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
35352     } catch (std::out_of_range& e) {
35353       {
35354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35355       };
35356     } catch (std::exception& e) {
35357       {
35358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35359       };
35360     } catch (...) {
35361       {
35362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35363       };
35364     }
35365   }
35366   jresult = (void *)result;
35367   return jresult;
35368 }
35369
35370
35371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
35372   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
35373
35374   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
35375   {
35376     try {
35377       delete arg1;
35378     } catch (std::out_of_range& e) {
35379       {
35380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35381       };
35382     } catch (std::exception& e) {
35383       {
35384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35385       };
35386     } catch (...) {
35387       {
35388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35389       };
35390     }
35391   }
35392 }
35393
35394
35395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
35396   void * jresult ;
35397   Dali::Radian *result = 0 ;
35398
35399   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
35400   jresult = (void *)result;
35401   return jresult;
35402 }
35403
35404
35405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
35406   void * jresult ;
35407   Dali::Radian *result = 0 ;
35408
35409   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
35410   jresult = (void *)result;
35411   return jresult;
35412 }
35413
35414
35415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
35416   void * jresult ;
35417   Dali::Radian *result = 0 ;
35418
35419   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
35420   jresult = (void *)result;
35421   return jresult;
35422 }
35423
35424
35425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
35426   void * jresult ;
35427   Dali::Radian *result = 0 ;
35428
35429   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
35430   jresult = (void *)result;
35431   return jresult;
35432 }
35433
35434
35435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
35436   void * jresult ;
35437   Dali::Radian *result = 0 ;
35438
35439   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
35440   jresult = (void *)result;
35441   return jresult;
35442 }
35443
35444
35445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
35446   void * jresult ;
35447   Dali::Radian *result = 0 ;
35448
35449   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
35450   jresult = (void *)result;
35451   return jresult;
35452 }
35453
35454
35455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
35456   void * jresult ;
35457   Dali::Radian *result = 0 ;
35458
35459   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
35460   jresult = (void *)result;
35461   return jresult;
35462 }
35463
35464
35465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
35466   void * jresult ;
35467   Dali::PanGestureDetector *result = 0 ;
35468
35469   {
35470     try {
35471       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
35472     } catch (std::out_of_range& e) {
35473       {
35474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35475       };
35476     } catch (std::exception& e) {
35477       {
35478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35479       };
35480     } catch (...) {
35481       {
35482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35483       };
35484     }
35485   }
35486   jresult = (void *)result;
35487   return jresult;
35488 }
35489
35490
35491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
35492   void * jresult ;
35493   Dali::PanGestureDetector result;
35494
35495   {
35496     try {
35497       result = Dali::PanGestureDetector::New();
35498     } catch (std::out_of_range& e) {
35499       {
35500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35501       };
35502     } catch (std::exception& e) {
35503       {
35504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35505       };
35506     } catch (...) {
35507       {
35508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35509       };
35510     }
35511   }
35512   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35513   return jresult;
35514 }
35515
35516
35517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
35518   void * jresult ;
35519   Dali::BaseHandle arg1 ;
35520   Dali::BaseHandle *argp1 ;
35521   Dali::PanGestureDetector result;
35522
35523   argp1 = (Dali::BaseHandle *)jarg1;
35524   if (!argp1) {
35525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35526     return 0;
35527   }
35528   arg1 = *argp1;
35529   {
35530     try {
35531       result = Dali::PanGestureDetector::DownCast(arg1);
35532     } catch (std::out_of_range& e) {
35533       {
35534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35535       };
35536     } catch (std::exception& e) {
35537       {
35538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35539       };
35540     } catch (...) {
35541       {
35542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35543       };
35544     }
35545   }
35546   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35547   return jresult;
35548 }
35549
35550
35551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
35552   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35553
35554   arg1 = (Dali::PanGestureDetector *)jarg1;
35555   {
35556     try {
35557       delete arg1;
35558     } catch (std::out_of_range& e) {
35559       {
35560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35561       };
35562     } catch (std::exception& e) {
35563       {
35564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35565       };
35566     } catch (...) {
35567       {
35568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35569       };
35570     }
35571   }
35572 }
35573
35574
35575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
35576   void * jresult ;
35577   Dali::PanGestureDetector *arg1 = 0 ;
35578   Dali::PanGestureDetector *result = 0 ;
35579
35580   arg1 = (Dali::PanGestureDetector *)jarg1;
35581   if (!arg1) {
35582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35583     return 0;
35584   }
35585   {
35586     try {
35587       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
35588     } catch (std::out_of_range& e) {
35589       {
35590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35591       };
35592     } catch (std::exception& e) {
35593       {
35594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35595       };
35596     } catch (...) {
35597       {
35598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35599       };
35600     }
35601   }
35602   jresult = (void *)result;
35603   return jresult;
35604 }
35605
35606
35607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
35608   void * jresult ;
35609   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35610   Dali::PanGestureDetector *arg2 = 0 ;
35611   Dali::PanGestureDetector *result = 0 ;
35612
35613   arg1 = (Dali::PanGestureDetector *)jarg1;
35614   arg2 = (Dali::PanGestureDetector *)jarg2;
35615   if (!arg2) {
35616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35617     return 0;
35618   }
35619   {
35620     try {
35621       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
35622     } catch (std::out_of_range& e) {
35623       {
35624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35625       };
35626     } catch (std::exception& e) {
35627       {
35628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35629       };
35630     } catch (...) {
35631       {
35632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35633       };
35634     }
35635   }
35636   jresult = (void *)result;
35637   return jresult;
35638 }
35639
35640
35641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
35642   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35643   unsigned int arg2 ;
35644
35645   arg1 = (Dali::PanGestureDetector *)jarg1;
35646   arg2 = (unsigned int)jarg2;
35647   {
35648     try {
35649       (arg1)->SetMinimumTouchesRequired(arg2);
35650     } catch (std::out_of_range& e) {
35651       {
35652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35653       };
35654     } catch (std::exception& e) {
35655       {
35656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35657       };
35658     } catch (...) {
35659       {
35660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35661       };
35662     }
35663   }
35664 }
35665
35666
35667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
35668   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35669   unsigned int arg2 ;
35670
35671   arg1 = (Dali::PanGestureDetector *)jarg1;
35672   arg2 = (unsigned int)jarg2;
35673   {
35674     try {
35675       (arg1)->SetMaximumTouchesRequired(arg2);
35676     } catch (std::out_of_range& e) {
35677       {
35678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35679       };
35680     } catch (std::exception& e) {
35681       {
35682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35683       };
35684     } catch (...) {
35685       {
35686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35687       };
35688     }
35689   }
35690 }
35691
35692
35693 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
35694   unsigned int jresult ;
35695   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35696   unsigned int result;
35697
35698   arg1 = (Dali::PanGestureDetector *)jarg1;
35699   {
35700     try {
35701       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
35702     } catch (std::out_of_range& e) {
35703       {
35704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35705       };
35706     } catch (std::exception& e) {
35707       {
35708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35709       };
35710     } catch (...) {
35711       {
35712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35713       };
35714     }
35715   }
35716   jresult = result;
35717   return jresult;
35718 }
35719
35720
35721 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
35722   unsigned int jresult ;
35723   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35724   unsigned int result;
35725
35726   arg1 = (Dali::PanGestureDetector *)jarg1;
35727   {
35728     try {
35729       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
35730     } catch (std::out_of_range& e) {
35731       {
35732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35733       };
35734     } catch (std::exception& e) {
35735       {
35736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35737       };
35738     } catch (...) {
35739       {
35740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35741       };
35742     }
35743   }
35744   jresult = result;
35745   return jresult;
35746 }
35747
35748
35749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35750   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35751   Dali::Radian arg2 ;
35752   Dali::Radian arg3 ;
35753   Dali::Radian *argp2 ;
35754   Dali::Radian *argp3 ;
35755
35756   arg1 = (Dali::PanGestureDetector *)jarg1;
35757   argp2 = (Dali::Radian *)jarg2;
35758   if (!argp2) {
35759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35760     return ;
35761   }
35762   arg2 = *argp2;
35763   argp3 = (Dali::Radian *)jarg3;
35764   if (!argp3) {
35765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35766     return ;
35767   }
35768   arg3 = *argp3;
35769   {
35770     try {
35771       (arg1)->AddAngle(arg2,arg3);
35772     } catch (std::out_of_range& e) {
35773       {
35774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35775       };
35776     } catch (std::exception& e) {
35777       {
35778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35779       };
35780     } catch (...) {
35781       {
35782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35783       };
35784     }
35785   }
35786 }
35787
35788
35789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
35790   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35791   Dali::Radian arg2 ;
35792   Dali::Radian *argp2 ;
35793
35794   arg1 = (Dali::PanGestureDetector *)jarg1;
35795   argp2 = (Dali::Radian *)jarg2;
35796   if (!argp2) {
35797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35798     return ;
35799   }
35800   arg2 = *argp2;
35801   {
35802     try {
35803       (arg1)->AddAngle(arg2);
35804     } catch (std::out_of_range& e) {
35805       {
35806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35807       };
35808     } catch (std::exception& e) {
35809       {
35810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35811       };
35812     } catch (...) {
35813       {
35814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35815       };
35816     }
35817   }
35818 }
35819
35820
35821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35822   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35823   Dali::Radian arg2 ;
35824   Dali::Radian arg3 ;
35825   Dali::Radian *argp2 ;
35826   Dali::Radian *argp3 ;
35827
35828   arg1 = (Dali::PanGestureDetector *)jarg1;
35829   argp2 = (Dali::Radian *)jarg2;
35830   if (!argp2) {
35831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35832     return ;
35833   }
35834   arg2 = *argp2;
35835   argp3 = (Dali::Radian *)jarg3;
35836   if (!argp3) {
35837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35838     return ;
35839   }
35840   arg3 = *argp3;
35841   {
35842     try {
35843       (arg1)->AddDirection(arg2,arg3);
35844     } catch (std::out_of_range& e) {
35845       {
35846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35847       };
35848     } catch (std::exception& e) {
35849       {
35850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35851       };
35852     } catch (...) {
35853       {
35854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35855       };
35856     }
35857   }
35858 }
35859
35860
35861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
35862   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35863   Dali::Radian arg2 ;
35864   Dali::Radian *argp2 ;
35865
35866   arg1 = (Dali::PanGestureDetector *)jarg1;
35867   argp2 = (Dali::Radian *)jarg2;
35868   if (!argp2) {
35869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35870     return ;
35871   }
35872   arg2 = *argp2;
35873   {
35874     try {
35875       (arg1)->AddDirection(arg2);
35876     } catch (std::out_of_range& e) {
35877       {
35878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35879       };
35880     } catch (std::exception& e) {
35881       {
35882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35883       };
35884     } catch (...) {
35885       {
35886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35887       };
35888     }
35889   }
35890 }
35891
35892
35893 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
35894   unsigned long jresult ;
35895   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35896   size_t result;
35897
35898   arg1 = (Dali::PanGestureDetector *)jarg1;
35899   {
35900     try {
35901       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
35902     } catch (std::out_of_range& e) {
35903       {
35904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35905       };
35906     } catch (std::exception& e) {
35907       {
35908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35909       };
35910     } catch (...) {
35911       {
35912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35913       };
35914     }
35915   }
35916   jresult = (unsigned long)result;
35917   return jresult;
35918 }
35919
35920
35921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
35922   void * jresult ;
35923   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35924   size_t arg2 ;
35925   Dali::PanGestureDetector::AngleThresholdPair result;
35926
35927   arg1 = (Dali::PanGestureDetector *)jarg1;
35928   arg2 = (size_t)jarg2;
35929   {
35930     try {
35931       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
35932     } catch (std::out_of_range& e) {
35933       {
35934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35935       };
35936     } catch (std::exception& e) {
35937       {
35938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35939       };
35940     } catch (...) {
35941       {
35942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35943       };
35944     }
35945   }
35946   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
35947   return jresult;
35948 }
35949
35950
35951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
35952   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35953
35954   arg1 = (Dali::PanGestureDetector *)jarg1;
35955   {
35956     try {
35957       (arg1)->ClearAngles();
35958     } catch (std::out_of_range& e) {
35959       {
35960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35961       };
35962     } catch (std::exception& e) {
35963       {
35964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35965       };
35966     } catch (...) {
35967       {
35968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35969       };
35970     }
35971   }
35972 }
35973
35974
35975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
35976   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35977   Dali::Radian arg2 ;
35978   Dali::Radian *argp2 ;
35979
35980   arg1 = (Dali::PanGestureDetector *)jarg1;
35981   argp2 = (Dali::Radian *)jarg2;
35982   if (!argp2) {
35983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35984     return ;
35985   }
35986   arg2 = *argp2;
35987   {
35988     try {
35989       (arg1)->RemoveAngle(arg2);
35990     } catch (std::out_of_range& e) {
35991       {
35992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35993       };
35994     } catch (std::exception& e) {
35995       {
35996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35997       };
35998     } catch (...) {
35999       {
36000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36001       };
36002     }
36003   }
36004 }
36005
36006
36007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
36008   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
36009   Dali::Radian arg2 ;
36010   Dali::Radian *argp2 ;
36011
36012   arg1 = (Dali::PanGestureDetector *)jarg1;
36013   argp2 = (Dali::Radian *)jarg2;
36014   if (!argp2) {
36015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
36016     return ;
36017   }
36018   arg2 = *argp2;
36019   {
36020     try {
36021       (arg1)->RemoveDirection(arg2);
36022     } catch (std::out_of_range& e) {
36023       {
36024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36025       };
36026     } catch (std::exception& e) {
36027       {
36028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36029       };
36030     } catch (...) {
36031       {
36032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36033       };
36034     }
36035   }
36036 }
36037
36038
36039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
36040   void * jresult ;
36041   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
36042   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
36043
36044   arg1 = (Dali::PanGestureDetector *)jarg1;
36045   {
36046     try {
36047       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36048     } catch (std::out_of_range& e) {
36049       {
36050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36051       };
36052     } catch (std::exception& e) {
36053       {
36054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36055       };
36056     } catch (...) {
36057       {
36058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36059       };
36060     }
36061   }
36062   jresult = (void *)result;
36063   return jresult;
36064 }
36065
36066
36067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
36068   Dali::PanGesture *arg1 = 0 ;
36069
36070   arg1 = (Dali::PanGesture *)jarg1;
36071   if (!arg1) {
36072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36073     return ;
36074   }
36075   {
36076     try {
36077       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
36078     } catch (std::out_of_range& e) {
36079       {
36080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36081       };
36082     } catch (std::exception& e) {
36083       {
36084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36085       };
36086     } catch (...) {
36087       {
36088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36089       };
36090     }
36091   }
36092 }
36093
36094
36095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
36096   void * jresult ;
36097   Dali::PanGesture *result = 0 ;
36098
36099   {
36100     try {
36101       result = (Dali::PanGesture *)new Dali::PanGesture();
36102     } catch (std::out_of_range& e) {
36103       {
36104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36105       };
36106     } catch (std::exception& e) {
36107       {
36108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36109       };
36110     } catch (...) {
36111       {
36112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36113       };
36114     }
36115   }
36116   jresult = (void *)result;
36117   return jresult;
36118 }
36119
36120
36121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
36122   void * jresult ;
36123   Dali::Gesture::State arg1 ;
36124   Dali::PanGesture *result = 0 ;
36125
36126   arg1 = (Dali::Gesture::State)jarg1;
36127   {
36128     try {
36129       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
36130     } catch (std::out_of_range& e) {
36131       {
36132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36133       };
36134     } catch (std::exception& e) {
36135       {
36136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36137       };
36138     } catch (...) {
36139       {
36140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36141       };
36142     }
36143   }
36144   jresult = (void *)result;
36145   return jresult;
36146 }
36147
36148
36149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
36150   void * jresult ;
36151   Dali::PanGesture *arg1 = 0 ;
36152   Dali::PanGesture *result = 0 ;
36153
36154   arg1 = (Dali::PanGesture *)jarg1;
36155   if (!arg1) {
36156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36157     return 0;
36158   }
36159   {
36160     try {
36161       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
36162     } catch (std::out_of_range& e) {
36163       {
36164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36165       };
36166     } catch (std::exception& e) {
36167       {
36168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36169       };
36170     } catch (...) {
36171       {
36172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36173       };
36174     }
36175   }
36176   jresult = (void *)result;
36177   return jresult;
36178 }
36179
36180
36181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
36182   void * jresult ;
36183   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36184   Dali::PanGesture *arg2 = 0 ;
36185   Dali::PanGesture *result = 0 ;
36186
36187   arg1 = (Dali::PanGesture *)jarg1;
36188   arg2 = (Dali::PanGesture *)jarg2;
36189   if (!arg2) {
36190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36191     return 0;
36192   }
36193   {
36194     try {
36195       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
36196     } catch (std::out_of_range& e) {
36197       {
36198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36199       };
36200     } catch (std::exception& e) {
36201       {
36202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36203       };
36204     } catch (...) {
36205       {
36206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36207       };
36208     }
36209   }
36210   jresult = (void *)result;
36211   return jresult;
36212 }
36213
36214
36215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
36216   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36217
36218   arg1 = (Dali::PanGesture *)jarg1;
36219   {
36220     try {
36221       delete arg1;
36222     } catch (std::out_of_range& e) {
36223       {
36224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36225       };
36226     } catch (std::exception& e) {
36227       {
36228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36229       };
36230     } catch (...) {
36231       {
36232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36233       };
36234     }
36235   }
36236 }
36237
36238
36239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
36240   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36241   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36242
36243   arg1 = (Dali::PanGesture *)jarg1;
36244   arg2 = (Dali::Vector2 *)jarg2;
36245   if (arg1) (arg1)->velocity = *arg2;
36246 }
36247
36248
36249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
36250   void * jresult ;
36251   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36252   Dali::Vector2 *result = 0 ;
36253
36254   arg1 = (Dali::PanGesture *)jarg1;
36255   result = (Dali::Vector2 *)& ((arg1)->velocity);
36256   jresult = (void *)result;
36257   return jresult;
36258 }
36259
36260
36261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
36262   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36263   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36264
36265   arg1 = (Dali::PanGesture *)jarg1;
36266   arg2 = (Dali::Vector2 *)jarg2;
36267   if (arg1) (arg1)->displacement = *arg2;
36268 }
36269
36270
36271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
36272   void * jresult ;
36273   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36274   Dali::Vector2 *result = 0 ;
36275
36276   arg1 = (Dali::PanGesture *)jarg1;
36277   result = (Dali::Vector2 *)& ((arg1)->displacement);
36278   jresult = (void *)result;
36279   return jresult;
36280 }
36281
36282
36283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
36284   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36285   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36286
36287   arg1 = (Dali::PanGesture *)jarg1;
36288   arg2 = (Dali::Vector2 *)jarg2;
36289   if (arg1) (arg1)->position = *arg2;
36290 }
36291
36292
36293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
36294   void * jresult ;
36295   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36296   Dali::Vector2 *result = 0 ;
36297
36298   arg1 = (Dali::PanGesture *)jarg1;
36299   result = (Dali::Vector2 *)& ((arg1)->position);
36300   jresult = (void *)result;
36301   return jresult;
36302 }
36303
36304
36305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
36306   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36307   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36308
36309   arg1 = (Dali::PanGesture *)jarg1;
36310   arg2 = (Dali::Vector2 *)jarg2;
36311   if (arg1) (arg1)->screenVelocity = *arg2;
36312 }
36313
36314
36315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
36316   void * jresult ;
36317   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36318   Dali::Vector2 *result = 0 ;
36319
36320   arg1 = (Dali::PanGesture *)jarg1;
36321   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
36322   jresult = (void *)result;
36323   return jresult;
36324 }
36325
36326
36327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
36328   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36329   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36330
36331   arg1 = (Dali::PanGesture *)jarg1;
36332   arg2 = (Dali::Vector2 *)jarg2;
36333   if (arg1) (arg1)->screenDisplacement = *arg2;
36334 }
36335
36336
36337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
36338   void * jresult ;
36339   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36340   Dali::Vector2 *result = 0 ;
36341
36342   arg1 = (Dali::PanGesture *)jarg1;
36343   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
36344   jresult = (void *)result;
36345   return jresult;
36346 }
36347
36348
36349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
36350   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36351   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36352
36353   arg1 = (Dali::PanGesture *)jarg1;
36354   arg2 = (Dali::Vector2 *)jarg2;
36355   if (arg1) (arg1)->screenPosition = *arg2;
36356 }
36357
36358
36359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
36360   void * jresult ;
36361   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36362   Dali::Vector2 *result = 0 ;
36363
36364   arg1 = (Dali::PanGesture *)jarg1;
36365   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
36366   jresult = (void *)result;
36367   return jresult;
36368 }
36369
36370
36371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
36372   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36373   unsigned int arg2 ;
36374
36375   arg1 = (Dali::PanGesture *)jarg1;
36376   arg2 = (unsigned int)jarg2;
36377   if (arg1) (arg1)->numberOfTouches = arg2;
36378 }
36379
36380
36381 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
36382   unsigned int jresult ;
36383   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36384   unsigned int result;
36385
36386   arg1 = (Dali::PanGesture *)jarg1;
36387   result = (unsigned int) ((arg1)->numberOfTouches);
36388   jresult = result;
36389   return jresult;
36390 }
36391
36392
36393 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
36394   float jresult ;
36395   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36396   float result;
36397
36398   arg1 = (Dali::PanGesture *)jarg1;
36399   {
36400     try {
36401       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
36402     } catch (std::out_of_range& e) {
36403       {
36404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36405       };
36406     } catch (std::exception& e) {
36407       {
36408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36409       };
36410     } catch (...) {
36411       {
36412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36413       };
36414     }
36415   }
36416   jresult = result;
36417   return jresult;
36418 }
36419
36420
36421 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
36422   float jresult ;
36423   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36424   float result;
36425
36426   arg1 = (Dali::PanGesture *)jarg1;
36427   {
36428     try {
36429       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
36430     } catch (std::out_of_range& e) {
36431       {
36432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36433       };
36434     } catch (std::exception& e) {
36435       {
36436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36437       };
36438     } catch (...) {
36439       {
36440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36441       };
36442     }
36443   }
36444   jresult = result;
36445   return jresult;
36446 }
36447
36448
36449 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
36450   float jresult ;
36451   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36452   float result;
36453
36454   arg1 = (Dali::PanGesture *)jarg1;
36455   {
36456     try {
36457       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
36458     } catch (std::out_of_range& e) {
36459       {
36460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36461       };
36462     } catch (std::exception& e) {
36463       {
36464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36465       };
36466     } catch (...) {
36467       {
36468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36469       };
36470     }
36471   }
36472   jresult = result;
36473   return jresult;
36474 }
36475
36476
36477 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
36478   float jresult ;
36479   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36480   float result;
36481
36482   arg1 = (Dali::PanGesture *)jarg1;
36483   {
36484     try {
36485       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
36486     } catch (std::out_of_range& e) {
36487       {
36488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36489       };
36490     } catch (std::exception& e) {
36491       {
36492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36493       };
36494     } catch (...) {
36495       {
36496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36497       };
36498     }
36499   }
36500   jresult = result;
36501   return jresult;
36502 }
36503
36504
36505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
36506   void * jresult ;
36507   Dali::PinchGestureDetector *result = 0 ;
36508
36509   {
36510     try {
36511       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
36512     } catch (std::out_of_range& e) {
36513       {
36514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36515       };
36516     } catch (std::exception& e) {
36517       {
36518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36519       };
36520     } catch (...) {
36521       {
36522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36523       };
36524     }
36525   }
36526   jresult = (void *)result;
36527   return jresult;
36528 }
36529
36530
36531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
36532   void * jresult ;
36533   Dali::PinchGestureDetector result;
36534
36535   {
36536     try {
36537       result = Dali::PinchGestureDetector::New();
36538     } catch (std::out_of_range& e) {
36539       {
36540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36541       };
36542     } catch (std::exception& e) {
36543       {
36544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36545       };
36546     } catch (...) {
36547       {
36548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36549       };
36550     }
36551   }
36552   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36553   return jresult;
36554 }
36555
36556
36557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
36558   void * jresult ;
36559   Dali::BaseHandle arg1 ;
36560   Dali::BaseHandle *argp1 ;
36561   Dali::PinchGestureDetector result;
36562
36563   argp1 = (Dali::BaseHandle *)jarg1;
36564   if (!argp1) {
36565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36566     return 0;
36567   }
36568   arg1 = *argp1;
36569   {
36570     try {
36571       result = Dali::PinchGestureDetector::DownCast(arg1);
36572     } catch (std::out_of_range& e) {
36573       {
36574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36575       };
36576     } catch (std::exception& e) {
36577       {
36578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36579       };
36580     } catch (...) {
36581       {
36582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36583       };
36584     }
36585   }
36586   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36587   return jresult;
36588 }
36589
36590
36591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
36592   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36593
36594   arg1 = (Dali::PinchGestureDetector *)jarg1;
36595   {
36596     try {
36597       delete arg1;
36598     } catch (std::out_of_range& e) {
36599       {
36600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36601       };
36602     } catch (std::exception& e) {
36603       {
36604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36605       };
36606     } catch (...) {
36607       {
36608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36609       };
36610     }
36611   }
36612 }
36613
36614
36615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
36616   void * jresult ;
36617   Dali::PinchGestureDetector *arg1 = 0 ;
36618   Dali::PinchGestureDetector *result = 0 ;
36619
36620   arg1 = (Dali::PinchGestureDetector *)jarg1;
36621   if (!arg1) {
36622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36623     return 0;
36624   }
36625   {
36626     try {
36627       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
36628     } catch (std::out_of_range& e) {
36629       {
36630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36631       };
36632     } catch (std::exception& e) {
36633       {
36634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36635       };
36636     } catch (...) {
36637       {
36638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36639       };
36640     }
36641   }
36642   jresult = (void *)result;
36643   return jresult;
36644 }
36645
36646
36647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
36648   void * jresult ;
36649   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36650   Dali::PinchGestureDetector *arg2 = 0 ;
36651   Dali::PinchGestureDetector *result = 0 ;
36652
36653   arg1 = (Dali::PinchGestureDetector *)jarg1;
36654   arg2 = (Dali::PinchGestureDetector *)jarg2;
36655   if (!arg2) {
36656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36657     return 0;
36658   }
36659   {
36660     try {
36661       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
36662     } catch (std::out_of_range& e) {
36663       {
36664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36665       };
36666     } catch (std::exception& e) {
36667       {
36668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36669       };
36670     } catch (...) {
36671       {
36672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36673       };
36674     }
36675   }
36676   jresult = (void *)result;
36677   return jresult;
36678 }
36679
36680
36681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
36682   void * jresult ;
36683   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36684   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
36685
36686   arg1 = (Dali::PinchGestureDetector *)jarg1;
36687   {
36688     try {
36689       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36690     } catch (std::out_of_range& e) {
36691       {
36692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36693       };
36694     } catch (std::exception& e) {
36695       {
36696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36697       };
36698     } catch (...) {
36699       {
36700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36701       };
36702     }
36703   }
36704   jresult = (void *)result;
36705   return jresult;
36706 }
36707
36708
36709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
36710   void * jresult ;
36711   Dali::Gesture::State arg1 ;
36712   Dali::PinchGesture *result = 0 ;
36713
36714   arg1 = (Dali::Gesture::State)jarg1;
36715   {
36716     try {
36717       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
36718     } catch (std::out_of_range& e) {
36719       {
36720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36721       };
36722     } catch (std::exception& e) {
36723       {
36724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36725       };
36726     } catch (...) {
36727       {
36728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36729       };
36730     }
36731   }
36732   jresult = (void *)result;
36733   return jresult;
36734 }
36735
36736
36737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
36738   void * jresult ;
36739   Dali::PinchGesture *arg1 = 0 ;
36740   Dali::PinchGesture *result = 0 ;
36741
36742   arg1 = (Dali::PinchGesture *)jarg1;
36743   if (!arg1) {
36744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36745     return 0;
36746   }
36747   {
36748     try {
36749       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
36750     } catch (std::out_of_range& e) {
36751       {
36752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36753       };
36754     } catch (std::exception& e) {
36755       {
36756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36757       };
36758     } catch (...) {
36759       {
36760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36761       };
36762     }
36763   }
36764   jresult = (void *)result;
36765   return jresult;
36766 }
36767
36768
36769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
36770   void * jresult ;
36771   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36772   Dali::PinchGesture *arg2 = 0 ;
36773   Dali::PinchGesture *result = 0 ;
36774
36775   arg1 = (Dali::PinchGesture *)jarg1;
36776   arg2 = (Dali::PinchGesture *)jarg2;
36777   if (!arg2) {
36778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36779     return 0;
36780   }
36781   {
36782     try {
36783       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
36784     } catch (std::out_of_range& e) {
36785       {
36786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36787       };
36788     } catch (std::exception& e) {
36789       {
36790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36791       };
36792     } catch (...) {
36793       {
36794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36795       };
36796     }
36797   }
36798   jresult = (void *)result;
36799   return jresult;
36800 }
36801
36802
36803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
36804   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36805
36806   arg1 = (Dali::PinchGesture *)jarg1;
36807   {
36808     try {
36809       delete arg1;
36810     } catch (std::out_of_range& e) {
36811       {
36812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36813       };
36814     } catch (std::exception& e) {
36815       {
36816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36817       };
36818     } catch (...) {
36819       {
36820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36821       };
36822     }
36823   }
36824 }
36825
36826
36827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
36828   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36829   float arg2 ;
36830
36831   arg1 = (Dali::PinchGesture *)jarg1;
36832   arg2 = (float)jarg2;
36833   if (arg1) (arg1)->scale = arg2;
36834 }
36835
36836
36837 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
36838   float jresult ;
36839   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36840   float result;
36841
36842   arg1 = (Dali::PinchGesture *)jarg1;
36843   result = (float) ((arg1)->scale);
36844   jresult = result;
36845   return jresult;
36846 }
36847
36848
36849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
36850   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36851   float arg2 ;
36852
36853   arg1 = (Dali::PinchGesture *)jarg1;
36854   arg2 = (float)jarg2;
36855   if (arg1) (arg1)->speed = arg2;
36856 }
36857
36858
36859 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
36860   float jresult ;
36861   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36862   float result;
36863
36864   arg1 = (Dali::PinchGesture *)jarg1;
36865   result = (float) ((arg1)->speed);
36866   jresult = result;
36867   return jresult;
36868 }
36869
36870
36871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
36872   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36873   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36874
36875   arg1 = (Dali::PinchGesture *)jarg1;
36876   arg2 = (Dali::Vector2 *)jarg2;
36877   if (arg1) (arg1)->screenCenterPoint = *arg2;
36878 }
36879
36880
36881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
36882   void * jresult ;
36883   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36884   Dali::Vector2 *result = 0 ;
36885
36886   arg1 = (Dali::PinchGesture *)jarg1;
36887   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
36888   jresult = (void *)result;
36889   return jresult;
36890 }
36891
36892
36893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
36894   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36895   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36896
36897   arg1 = (Dali::PinchGesture *)jarg1;
36898   arg2 = (Dali::Vector2 *)jarg2;
36899   if (arg1) (arg1)->localCenterPoint = *arg2;
36900 }
36901
36902
36903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
36904   void * jresult ;
36905   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36906   Dali::Vector2 *result = 0 ;
36907
36908   arg1 = (Dali::PinchGesture *)jarg1;
36909   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
36910   jresult = (void *)result;
36911   return jresult;
36912 }
36913
36914
36915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
36916   void * jresult ;
36917   Dali::TapGestureDetector *result = 0 ;
36918
36919   {
36920     try {
36921       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
36922     } catch (std::out_of_range& e) {
36923       {
36924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36925       };
36926     } catch (std::exception& e) {
36927       {
36928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36929       };
36930     } catch (...) {
36931       {
36932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36933       };
36934     }
36935   }
36936   jresult = (void *)result;
36937   return jresult;
36938 }
36939
36940
36941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
36942   void * jresult ;
36943   Dali::TapGestureDetector result;
36944
36945   {
36946     try {
36947       result = Dali::TapGestureDetector::New();
36948     } catch (std::out_of_range& e) {
36949       {
36950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36951       };
36952     } catch (std::exception& e) {
36953       {
36954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36955       };
36956     } catch (...) {
36957       {
36958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36959       };
36960     }
36961   }
36962   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36963   return jresult;
36964 }
36965
36966
36967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
36968   void * jresult ;
36969   unsigned int arg1 ;
36970   Dali::TapGestureDetector result;
36971
36972   arg1 = (unsigned int)jarg1;
36973   {
36974     try {
36975       result = Dali::TapGestureDetector::New(arg1);
36976     } catch (std::out_of_range& e) {
36977       {
36978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36979       };
36980     } catch (std::exception& e) {
36981       {
36982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36983       };
36984     } catch (...) {
36985       {
36986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36987       };
36988     }
36989   }
36990   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36991   return jresult;
36992 }
36993
36994
36995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
36996   void * jresult ;
36997   Dali::BaseHandle arg1 ;
36998   Dali::BaseHandle *argp1 ;
36999   Dali::TapGestureDetector result;
37000
37001   argp1 = (Dali::BaseHandle *)jarg1;
37002   if (!argp1) {
37003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37004     return 0;
37005   }
37006   arg1 = *argp1;
37007   {
37008     try {
37009       result = Dali::TapGestureDetector::DownCast(arg1);
37010     } catch (std::out_of_range& e) {
37011       {
37012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37013       };
37014     } catch (std::exception& e) {
37015       {
37016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37017       };
37018     } catch (...) {
37019       {
37020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37021       };
37022     }
37023   }
37024   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
37025   return jresult;
37026 }
37027
37028
37029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
37030   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37031
37032   arg1 = (Dali::TapGestureDetector *)jarg1;
37033   {
37034     try {
37035       delete arg1;
37036     } catch (std::out_of_range& e) {
37037       {
37038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37039       };
37040     } catch (std::exception& e) {
37041       {
37042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37043       };
37044     } catch (...) {
37045       {
37046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37047       };
37048     }
37049   }
37050 }
37051
37052
37053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
37054   void * jresult ;
37055   Dali::TapGestureDetector *arg1 = 0 ;
37056   Dali::TapGestureDetector *result = 0 ;
37057
37058   arg1 = (Dali::TapGestureDetector *)jarg1;
37059   if (!arg1) {
37060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
37061     return 0;
37062   }
37063   {
37064     try {
37065       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
37066     } catch (std::out_of_range& e) {
37067       {
37068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37069       };
37070     } catch (std::exception& e) {
37071       {
37072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37073       };
37074     } catch (...) {
37075       {
37076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37077       };
37078     }
37079   }
37080   jresult = (void *)result;
37081   return jresult;
37082 }
37083
37084
37085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
37086   void * jresult ;
37087   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37088   Dali::TapGestureDetector *arg2 = 0 ;
37089   Dali::TapGestureDetector *result = 0 ;
37090
37091   arg1 = (Dali::TapGestureDetector *)jarg1;
37092   arg2 = (Dali::TapGestureDetector *)jarg2;
37093   if (!arg2) {
37094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
37095     return 0;
37096   }
37097   {
37098     try {
37099       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
37100     } catch (std::out_of_range& e) {
37101       {
37102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37103       };
37104     } catch (std::exception& e) {
37105       {
37106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37107       };
37108     } catch (...) {
37109       {
37110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37111       };
37112     }
37113   }
37114   jresult = (void *)result;
37115   return jresult;
37116 }
37117
37118
37119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
37120   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37121   unsigned int arg2 ;
37122
37123   arg1 = (Dali::TapGestureDetector *)jarg1;
37124   arg2 = (unsigned int)jarg2;
37125   {
37126     try {
37127       (arg1)->SetMinimumTapsRequired(arg2);
37128     } catch (std::out_of_range& e) {
37129       {
37130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37131       };
37132     } catch (std::exception& e) {
37133       {
37134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37135       };
37136     } catch (...) {
37137       {
37138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37139       };
37140     }
37141   }
37142 }
37143
37144
37145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
37146   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37147   unsigned int arg2 ;
37148
37149   arg1 = (Dali::TapGestureDetector *)jarg1;
37150   arg2 = (unsigned int)jarg2;
37151   {
37152     try {
37153       (arg1)->SetMaximumTapsRequired(arg2);
37154     } catch (std::out_of_range& e) {
37155       {
37156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37157       };
37158     } catch (std::exception& e) {
37159       {
37160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37161       };
37162     } catch (...) {
37163       {
37164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37165       };
37166     }
37167   }
37168 }
37169
37170
37171 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
37172   unsigned int jresult ;
37173   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37174   unsigned int result;
37175
37176   arg1 = (Dali::TapGestureDetector *)jarg1;
37177   {
37178     try {
37179       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
37180     } catch (std::out_of_range& e) {
37181       {
37182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37183       };
37184     } catch (std::exception& e) {
37185       {
37186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37187       };
37188     } catch (...) {
37189       {
37190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37191       };
37192     }
37193   }
37194   jresult = result;
37195   return jresult;
37196 }
37197
37198
37199 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
37200   unsigned int jresult ;
37201   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37202   unsigned int result;
37203
37204   arg1 = (Dali::TapGestureDetector *)jarg1;
37205   {
37206     try {
37207       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
37208     } catch (std::out_of_range& e) {
37209       {
37210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37211       };
37212     } catch (std::exception& e) {
37213       {
37214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37215       };
37216     } catch (...) {
37217       {
37218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37219       };
37220     }
37221   }
37222   jresult = result;
37223   return jresult;
37224 }
37225
37226
37227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
37228   void * jresult ;
37229   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37230   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
37231
37232   arg1 = (Dali::TapGestureDetector *)jarg1;
37233   {
37234     try {
37235       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
37236     } catch (std::out_of_range& e) {
37237       {
37238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37239       };
37240     } catch (std::exception& e) {
37241       {
37242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37243       };
37244     } catch (...) {
37245       {
37246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37247       };
37248     }
37249   }
37250   jresult = (void *)result;
37251   return jresult;
37252 }
37253
37254
37255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
37256   void * jresult ;
37257   Dali::TapGesture *result = 0 ;
37258
37259   {
37260     try {
37261       result = (Dali::TapGesture *)new Dali::TapGesture();
37262     } catch (std::out_of_range& e) {
37263       {
37264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37265       };
37266     } catch (std::exception& e) {
37267       {
37268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37269       };
37270     } catch (...) {
37271       {
37272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37273       };
37274     }
37275   }
37276   jresult = (void *)result;
37277   return jresult;
37278 }
37279
37280
37281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
37282   void * jresult ;
37283   Dali::TapGesture *arg1 = 0 ;
37284   Dali::TapGesture *result = 0 ;
37285
37286   arg1 = (Dali::TapGesture *)jarg1;
37287   if (!arg1) {
37288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37289     return 0;
37290   }
37291   {
37292     try {
37293       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
37294     } catch (std::out_of_range& e) {
37295       {
37296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37297       };
37298     } catch (std::exception& e) {
37299       {
37300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37301       };
37302     } catch (...) {
37303       {
37304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37305       };
37306     }
37307   }
37308   jresult = (void *)result;
37309   return jresult;
37310 }
37311
37312
37313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
37314   void * jresult ;
37315   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37316   Dali::TapGesture *arg2 = 0 ;
37317   Dali::TapGesture *result = 0 ;
37318
37319   arg1 = (Dali::TapGesture *)jarg1;
37320   arg2 = (Dali::TapGesture *)jarg2;
37321   if (!arg2) {
37322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37323     return 0;
37324   }
37325   {
37326     try {
37327       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
37328     } catch (std::out_of_range& e) {
37329       {
37330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37331       };
37332     } catch (std::exception& e) {
37333       {
37334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37335       };
37336     } catch (...) {
37337       {
37338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37339       };
37340     }
37341   }
37342   jresult = (void *)result;
37343   return jresult;
37344 }
37345
37346
37347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
37348   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37349
37350   arg1 = (Dali::TapGesture *)jarg1;
37351   {
37352     try {
37353       delete arg1;
37354     } catch (std::out_of_range& e) {
37355       {
37356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37357       };
37358     } catch (std::exception& e) {
37359       {
37360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37361       };
37362     } catch (...) {
37363       {
37364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37365       };
37366     }
37367   }
37368 }
37369
37370
37371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
37372   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37373   unsigned int arg2 ;
37374
37375   arg1 = (Dali::TapGesture *)jarg1;
37376   arg2 = (unsigned int)jarg2;
37377   if (arg1) (arg1)->numberOfTaps = arg2;
37378 }
37379
37380
37381 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
37382   unsigned int jresult ;
37383   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37384   unsigned int result;
37385
37386   arg1 = (Dali::TapGesture *)jarg1;
37387   result = (unsigned int) ((arg1)->numberOfTaps);
37388   jresult = result;
37389   return jresult;
37390 }
37391
37392
37393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
37394   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37395   unsigned int arg2 ;
37396
37397   arg1 = (Dali::TapGesture *)jarg1;
37398   arg2 = (unsigned int)jarg2;
37399   if (arg1) (arg1)->numberOfTouches = arg2;
37400 }
37401
37402
37403 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
37404   unsigned int jresult ;
37405   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37406   unsigned int result;
37407
37408   arg1 = (Dali::TapGesture *)jarg1;
37409   result = (unsigned int) ((arg1)->numberOfTouches);
37410   jresult = result;
37411   return jresult;
37412 }
37413
37414
37415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
37416   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37417   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37418
37419   arg1 = (Dali::TapGesture *)jarg1;
37420   arg2 = (Dali::Vector2 *)jarg2;
37421   if (arg1) (arg1)->screenPoint = *arg2;
37422 }
37423
37424
37425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
37426   void * jresult ;
37427   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37428   Dali::Vector2 *result = 0 ;
37429
37430   arg1 = (Dali::TapGesture *)jarg1;
37431   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
37432   jresult = (void *)result;
37433   return jresult;
37434 }
37435
37436
37437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
37438   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37439   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37440
37441   arg1 = (Dali::TapGesture *)jarg1;
37442   arg2 = (Dali::Vector2 *)jarg2;
37443   if (arg1) (arg1)->localPoint = *arg2;
37444 }
37445
37446
37447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
37448   void * jresult ;
37449   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37450   Dali::Vector2 *result = 0 ;
37451
37452   arg1 = (Dali::TapGesture *)jarg1;
37453   result = (Dali::Vector2 *)& ((arg1)->localPoint);
37454   jresult = (void *)result;
37455   return jresult;
37456 }
37457
37458
37459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
37460   void * jresult ;
37461   Dali::AlphaFunction *result = 0 ;
37462
37463   {
37464     try {
37465       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
37466     } catch (std::out_of_range& e) {
37467       {
37468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37469       };
37470     } catch (std::exception& e) {
37471       {
37472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37473       };
37474     } catch (...) {
37475       {
37476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37477       };
37478     }
37479   }
37480   jresult = (void *)result;
37481   return jresult;
37482 }
37483
37484
37485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
37486   void * jresult ;
37487   Dali::AlphaFunction::BuiltinFunction arg1 ;
37488   Dali::AlphaFunction *result = 0 ;
37489
37490   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
37491   {
37492     try {
37493       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37494     } catch (std::out_of_range& e) {
37495       {
37496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37497       };
37498     } catch (std::exception& e) {
37499       {
37500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37501       };
37502     } catch (...) {
37503       {
37504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37505       };
37506     }
37507   }
37508   jresult = (void *)result;
37509   return jresult;
37510 }
37511
37512
37513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
37514   void * jresult ;
37515   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
37516   Dali::AlphaFunction *result = 0 ;
37517
37518   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
37519   {
37520     try {
37521       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37522     } catch (std::out_of_range& e) {
37523       {
37524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37525       };
37526     } catch (std::exception& e) {
37527       {
37528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37529       };
37530     } catch (...) {
37531       {
37532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37533       };
37534     }
37535   }
37536   jresult = (void *)result;
37537   return jresult;
37538 }
37539
37540
37541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
37542   void * jresult ;
37543   Dali::Vector2 *arg1 = 0 ;
37544   Dali::Vector2 *arg2 = 0 ;
37545   Dali::AlphaFunction *result = 0 ;
37546
37547   arg1 = (Dali::Vector2 *)jarg1;
37548   if (!arg1) {
37549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37550     return 0;
37551   }
37552   arg2 = (Dali::Vector2 *)jarg2;
37553   if (!arg2) {
37554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37555     return 0;
37556   }
37557   {
37558     try {
37559       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
37560     } catch (std::out_of_range& e) {
37561       {
37562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37563       };
37564     } catch (std::exception& e) {
37565       {
37566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37567       };
37568     } catch (...) {
37569       {
37570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37571       };
37572     }
37573   }
37574   jresult = (void *)result;
37575   return jresult;
37576 }
37577
37578
37579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
37580   void * jresult ;
37581   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37582   Dali::Vector4 result;
37583
37584   arg1 = (Dali::AlphaFunction *)jarg1;
37585   {
37586     try {
37587       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
37588     } catch (std::out_of_range& e) {
37589       {
37590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37591       };
37592     } catch (std::exception& e) {
37593       {
37594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37595       };
37596     } catch (...) {
37597       {
37598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37599       };
37600     }
37601   }
37602   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
37603   return jresult;
37604 }
37605
37606
37607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
37608   void * jresult ;
37609   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37610   Dali::AlphaFunctionPrototype result;
37611
37612   arg1 = (Dali::AlphaFunction *)jarg1;
37613   {
37614     try {
37615       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
37616     } catch (std::out_of_range& e) {
37617       {
37618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37619       };
37620     } catch (std::exception& e) {
37621       {
37622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37623       };
37624     } catch (...) {
37625       {
37626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37627       };
37628     }
37629   }
37630   jresult = (void *)result;
37631   return jresult;
37632 }
37633
37634
37635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
37636   int jresult ;
37637   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37638   Dali::AlphaFunction::BuiltinFunction result;
37639
37640   arg1 = (Dali::AlphaFunction *)jarg1;
37641   {
37642     try {
37643       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
37644     } catch (std::out_of_range& e) {
37645       {
37646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37647       };
37648     } catch (std::exception& e) {
37649       {
37650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37651       };
37652     } catch (...) {
37653       {
37654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37655       };
37656     }
37657   }
37658   jresult = (int)result;
37659   return jresult;
37660 }
37661
37662
37663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
37664   int jresult ;
37665   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37666   Dali::AlphaFunction::Mode result;
37667
37668   arg1 = (Dali::AlphaFunction *)jarg1;
37669   {
37670     try {
37671       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
37672     } catch (std::out_of_range& e) {
37673       {
37674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37675       };
37676     } catch (std::exception& e) {
37677       {
37678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37679       };
37680     } catch (...) {
37681       {
37682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37683       };
37684     }
37685   }
37686   jresult = (int)result;
37687   return jresult;
37688 }
37689
37690
37691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
37692   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37693
37694   arg1 = (Dali::AlphaFunction *)jarg1;
37695   {
37696     try {
37697       delete arg1;
37698     } catch (std::out_of_range& e) {
37699       {
37700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37701       };
37702     } catch (std::exception& e) {
37703       {
37704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37705       };
37706     } catch (...) {
37707       {
37708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37709       };
37710     }
37711   }
37712 }
37713
37714
37715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
37716   void * jresult ;
37717   Dali::KeyFrames result;
37718
37719   {
37720     try {
37721       result = Dali::KeyFrames::New();
37722     } catch (std::out_of_range& e) {
37723       {
37724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37725       };
37726     } catch (std::exception& e) {
37727       {
37728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37729       };
37730     } catch (...) {
37731       {
37732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37733       };
37734     }
37735   }
37736   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37737   return jresult;
37738 }
37739
37740
37741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
37742   void * jresult ;
37743   Dali::BaseHandle arg1 ;
37744   Dali::BaseHandle *argp1 ;
37745   Dali::KeyFrames result;
37746
37747   argp1 = (Dali::BaseHandle *)jarg1;
37748   if (!argp1) {
37749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37750     return 0;
37751   }
37752   arg1 = *argp1;
37753   {
37754     try {
37755       result = Dali::KeyFrames::DownCast(arg1);
37756     } catch (std::out_of_range& e) {
37757       {
37758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37759       };
37760     } catch (std::exception& e) {
37761       {
37762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37763       };
37764     } catch (...) {
37765       {
37766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37767       };
37768     }
37769   }
37770   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37771   return jresult;
37772 }
37773
37774
37775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
37776   void * jresult ;
37777   Dali::KeyFrames *result = 0 ;
37778
37779   {
37780     try {
37781       result = (Dali::KeyFrames *)new Dali::KeyFrames();
37782     } catch (std::out_of_range& e) {
37783       {
37784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37785       };
37786     } catch (std::exception& e) {
37787       {
37788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37789       };
37790     } catch (...) {
37791       {
37792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37793       };
37794     }
37795   }
37796   jresult = (void *)result;
37797   return jresult;
37798 }
37799
37800
37801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
37802   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37803
37804   arg1 = (Dali::KeyFrames *)jarg1;
37805   {
37806     try {
37807       delete arg1;
37808     } catch (std::out_of_range& e) {
37809       {
37810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37811       };
37812     } catch (std::exception& e) {
37813       {
37814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37815       };
37816     } catch (...) {
37817       {
37818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37819       };
37820     }
37821   }
37822 }
37823
37824
37825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
37826   void * jresult ;
37827   Dali::KeyFrames *arg1 = 0 ;
37828   Dali::KeyFrames *result = 0 ;
37829
37830   arg1 = (Dali::KeyFrames *)jarg1;
37831   if (!arg1) {
37832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37833     return 0;
37834   }
37835   {
37836     try {
37837       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
37838     } catch (std::out_of_range& e) {
37839       {
37840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37841       };
37842     } catch (std::exception& e) {
37843       {
37844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37845       };
37846     } catch (...) {
37847       {
37848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37849       };
37850     }
37851   }
37852   jresult = (void *)result;
37853   return jresult;
37854 }
37855
37856
37857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
37858   void * jresult ;
37859   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37860   Dali::KeyFrames *arg2 = 0 ;
37861   Dali::KeyFrames *result = 0 ;
37862
37863   arg1 = (Dali::KeyFrames *)jarg1;
37864   arg2 = (Dali::KeyFrames *)jarg2;
37865   if (!arg2) {
37866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37867     return 0;
37868   }
37869   {
37870     try {
37871       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
37872     } catch (std::out_of_range& e) {
37873       {
37874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37875       };
37876     } catch (std::exception& e) {
37877       {
37878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37879       };
37880     } catch (...) {
37881       {
37882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37883       };
37884     }
37885   }
37886   jresult = (void *)result;
37887   return jresult;
37888 }
37889
37890
37891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
37892   int jresult ;
37893   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37894   Dali::Property::Type result;
37895
37896   arg1 = (Dali::KeyFrames *)jarg1;
37897   {
37898     try {
37899       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
37900     } catch (std::out_of_range& e) {
37901       {
37902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37903       };
37904     } catch (std::exception& e) {
37905       {
37906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37907       };
37908     } catch (...) {
37909       {
37910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37911       };
37912     }
37913   }
37914   jresult = (int)result;
37915   return jresult;
37916 }
37917
37918
37919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
37920   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37921   float arg2 ;
37922   Dali::Property::Value arg3 ;
37923   Dali::Property::Value *argp3 ;
37924
37925   arg1 = (Dali::KeyFrames *)jarg1;
37926   arg2 = (float)jarg2;
37927   argp3 = (Dali::Property::Value *)jarg3;
37928   if (!argp3) {
37929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37930     return ;
37931   }
37932   arg3 = *argp3;
37933   {
37934     try {
37935       (arg1)->Add(arg2,arg3);
37936     } catch (std::out_of_range& e) {
37937       {
37938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37939       };
37940     } catch (std::exception& e) {
37941       {
37942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37943       };
37944     } catch (...) {
37945       {
37946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37947       };
37948     }
37949   }
37950 }
37951
37952
37953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
37954   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37955   float arg2 ;
37956   Dali::Property::Value arg3 ;
37957   Dali::AlphaFunction arg4 ;
37958   Dali::Property::Value *argp3 ;
37959   Dali::AlphaFunction *argp4 ;
37960
37961   arg1 = (Dali::KeyFrames *)jarg1;
37962   arg2 = (float)jarg2;
37963   argp3 = (Dali::Property::Value *)jarg3;
37964   if (!argp3) {
37965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37966     return ;
37967   }
37968   arg3 = *argp3;
37969   argp4 = (Dali::AlphaFunction *)jarg4;
37970   if (!argp4) {
37971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
37972     return ;
37973   }
37974   arg4 = *argp4;
37975   {
37976     try {
37977       (arg1)->Add(arg2,arg3,arg4);
37978     } catch (std::out_of_range& e) {
37979       {
37980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37981       };
37982     } catch (std::exception& e) {
37983       {
37984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37985       };
37986     } catch (...) {
37987       {
37988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37989       };
37990     }
37991   }
37992 }
37993
37994
37995 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
37996   int jresult ;
37997   int result;
37998
37999   result = (int)Dali::Path::Property::POINTS;
38000   jresult = (int)result;
38001   return jresult;
38002 }
38003
38004
38005 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
38006   int jresult ;
38007   int result;
38008
38009   result = (int)Dali::Path::Property::CONTROL_POINTS;
38010   jresult = (int)result;
38011   return jresult;
38012 }
38013
38014
38015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
38016   void * jresult ;
38017   Dali::Path::Property *result = 0 ;
38018
38019   {
38020     try {
38021       result = (Dali::Path::Property *)new Dali::Path::Property();
38022     } catch (std::out_of_range& e) {
38023       {
38024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38025       };
38026     } catch (std::exception& e) {
38027       {
38028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38029       };
38030     } catch (...) {
38031       {
38032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38033       };
38034     }
38035   }
38036   jresult = (void *)result;
38037   return jresult;
38038 }
38039
38040
38041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
38042   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
38043
38044   arg1 = (Dali::Path::Property *)jarg1;
38045   {
38046     try {
38047       delete arg1;
38048     } catch (std::out_of_range& e) {
38049       {
38050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38051       };
38052     } catch (std::exception& e) {
38053       {
38054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38055       };
38056     } catch (...) {
38057       {
38058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38059       };
38060     }
38061   }
38062 }
38063
38064
38065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
38066   void * jresult ;
38067   Dali::Path result;
38068
38069   {
38070     try {
38071       result = Dali::Path::New();
38072     } catch (std::out_of_range& e) {
38073       {
38074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38075       };
38076     } catch (std::exception& e) {
38077       {
38078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38079       };
38080     } catch (...) {
38081       {
38082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38083       };
38084     }
38085   }
38086   jresult = new Dali::Path((const Dali::Path &)result);
38087   return jresult;
38088 }
38089
38090
38091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
38092   void * jresult ;
38093   Dali::BaseHandle arg1 ;
38094   Dali::BaseHandle *argp1 ;
38095   Dali::Path result;
38096
38097   argp1 = (Dali::BaseHandle *)jarg1;
38098   if (!argp1) {
38099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38100     return 0;
38101   }
38102   arg1 = *argp1;
38103   {
38104     try {
38105       result = Dali::Path::DownCast(arg1);
38106     } catch (std::out_of_range& e) {
38107       {
38108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38109       };
38110     } catch (std::exception& e) {
38111       {
38112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38113       };
38114     } catch (...) {
38115       {
38116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38117       };
38118     }
38119   }
38120   jresult = new Dali::Path((const Dali::Path &)result);
38121   return jresult;
38122 }
38123
38124
38125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
38126   void * jresult ;
38127   Dali::Path *result = 0 ;
38128
38129   {
38130     try {
38131       result = (Dali::Path *)new Dali::Path();
38132     } catch (std::out_of_range& e) {
38133       {
38134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38135       };
38136     } catch (std::exception& e) {
38137       {
38138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38139       };
38140     } catch (...) {
38141       {
38142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38143       };
38144     }
38145   }
38146   jresult = (void *)result;
38147   return jresult;
38148 }
38149
38150
38151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
38152   Dali::Path *arg1 = (Dali::Path *) 0 ;
38153
38154   arg1 = (Dali::Path *)jarg1;
38155   {
38156     try {
38157       delete arg1;
38158     } catch (std::out_of_range& e) {
38159       {
38160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38161       };
38162     } catch (std::exception& e) {
38163       {
38164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38165       };
38166     } catch (...) {
38167       {
38168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38169       };
38170     }
38171   }
38172 }
38173
38174
38175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
38176   void * jresult ;
38177   Dali::Path *arg1 = 0 ;
38178   Dali::Path *result = 0 ;
38179
38180   arg1 = (Dali::Path *)jarg1;
38181   if (!arg1) {
38182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
38183     return 0;
38184   }
38185   {
38186     try {
38187       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
38188     } catch (std::out_of_range& e) {
38189       {
38190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38191       };
38192     } catch (std::exception& e) {
38193       {
38194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38195       };
38196     } catch (...) {
38197       {
38198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38199       };
38200     }
38201   }
38202   jresult = (void *)result;
38203   return jresult;
38204 }
38205
38206
38207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
38208   void * jresult ;
38209   Dali::Path *arg1 = (Dali::Path *) 0 ;
38210   Dali::Path *arg2 = 0 ;
38211   Dali::Path *result = 0 ;
38212
38213   arg1 = (Dali::Path *)jarg1;
38214   arg2 = (Dali::Path *)jarg2;
38215   if (!arg2) {
38216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
38217     return 0;
38218   }
38219   {
38220     try {
38221       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
38222     } catch (std::out_of_range& e) {
38223       {
38224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38225       };
38226     } catch (std::exception& e) {
38227       {
38228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38229       };
38230     } catch (...) {
38231       {
38232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38233       };
38234     }
38235   }
38236   jresult = (void *)result;
38237   return jresult;
38238 }
38239
38240
38241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
38242   Dali::Path *arg1 = (Dali::Path *) 0 ;
38243   Dali::Vector3 *arg2 = 0 ;
38244
38245   arg1 = (Dali::Path *)jarg1;
38246   arg2 = (Dali::Vector3 *)jarg2;
38247   if (!arg2) {
38248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38249     return ;
38250   }
38251   {
38252     try {
38253       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
38254     } catch (std::out_of_range& e) {
38255       {
38256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38257       };
38258     } catch (std::exception& e) {
38259       {
38260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38261       };
38262     } catch (...) {
38263       {
38264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38265       };
38266     }
38267   }
38268 }
38269
38270
38271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
38272   Dali::Path *arg1 = (Dali::Path *) 0 ;
38273   Dali::Vector3 *arg2 = 0 ;
38274
38275   arg1 = (Dali::Path *)jarg1;
38276   arg2 = (Dali::Vector3 *)jarg2;
38277   if (!arg2) {
38278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38279     return ;
38280   }
38281   {
38282     try {
38283       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
38284     } catch (std::out_of_range& e) {
38285       {
38286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38287       };
38288     } catch (std::exception& e) {
38289       {
38290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38291       };
38292     } catch (...) {
38293       {
38294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38295       };
38296     }
38297   }
38298 }
38299
38300
38301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
38302   Dali::Path *arg1 = (Dali::Path *) 0 ;
38303   float arg2 ;
38304
38305   arg1 = (Dali::Path *)jarg1;
38306   arg2 = (float)jarg2;
38307   {
38308     try {
38309       (arg1)->GenerateControlPoints(arg2);
38310     } catch (std::out_of_range& e) {
38311       {
38312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38313       };
38314     } catch (std::exception& e) {
38315       {
38316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38317       };
38318     } catch (...) {
38319       {
38320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38321       };
38322     }
38323   }
38324 }
38325
38326
38327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
38328   Dali::Path *arg1 = (Dali::Path *) 0 ;
38329   float arg2 ;
38330   Dali::Vector3 *arg3 = 0 ;
38331   Dali::Vector3 *arg4 = 0 ;
38332
38333   arg1 = (Dali::Path *)jarg1;
38334   arg2 = (float)jarg2;
38335   arg3 = (Dali::Vector3 *)jarg3;
38336   if (!arg3) {
38337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38338     return ;
38339   }
38340   arg4 = (Dali::Vector3 *)jarg4;
38341   if (!arg4) {
38342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38343     return ;
38344   }
38345   {
38346     try {
38347       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
38348     } catch (std::out_of_range& e) {
38349       {
38350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38351       };
38352     } catch (std::exception& e) {
38353       {
38354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38355       };
38356     } catch (...) {
38357       {
38358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38359       };
38360     }
38361   }
38362 }
38363
38364
38365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
38366   void * jresult ;
38367   Dali::Path *arg1 = (Dali::Path *) 0 ;
38368   size_t arg2 ;
38369   Dali::Vector3 *result = 0 ;
38370
38371   arg1 = (Dali::Path *)jarg1;
38372   arg2 = (size_t)jarg2;
38373   {
38374     try {
38375       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
38376     } catch (std::out_of_range& e) {
38377       {
38378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38379       };
38380     } catch (std::exception& e) {
38381       {
38382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38383       };
38384     } catch (...) {
38385       {
38386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38387       };
38388     }
38389   }
38390   jresult = (void *)result;
38391   return jresult;
38392 }
38393
38394
38395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
38396   void * jresult ;
38397   Dali::Path *arg1 = (Dali::Path *) 0 ;
38398   size_t arg2 ;
38399   Dali::Vector3 *result = 0 ;
38400
38401   arg1 = (Dali::Path *)jarg1;
38402   arg2 = (size_t)jarg2;
38403   {
38404     try {
38405       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
38406     } catch (std::out_of_range& e) {
38407       {
38408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38409       };
38410     } catch (std::exception& e) {
38411       {
38412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38413       };
38414     } catch (...) {
38415       {
38416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38417       };
38418     }
38419   }
38420   jresult = (void *)result;
38421   return jresult;
38422 }
38423
38424
38425 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
38426   unsigned long jresult ;
38427   Dali::Path *arg1 = (Dali::Path *) 0 ;
38428   size_t result;
38429
38430   arg1 = (Dali::Path *)jarg1;
38431   {
38432     try {
38433       result = ((Dali::Path const *)arg1)->GetPointCount();
38434     } catch (std::out_of_range& e) {
38435       {
38436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38437       };
38438     } catch (std::exception& e) {
38439       {
38440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38441       };
38442     } catch (...) {
38443       {
38444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38445       };
38446     }
38447   }
38448   jresult = (unsigned long)result;
38449   return jresult;
38450 }
38451
38452
38453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
38454   void * jresult ;
38455   float arg1 ;
38456   Dali::TimePeriod *result = 0 ;
38457
38458   arg1 = (float)jarg1;
38459   {
38460     try {
38461       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
38462     } catch (std::out_of_range& e) {
38463       {
38464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38465       };
38466     } catch (std::exception& e) {
38467       {
38468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38469       };
38470     } catch (...) {
38471       {
38472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38473       };
38474     }
38475   }
38476   jresult = (void *)result;
38477   return jresult;
38478 }
38479
38480
38481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
38482   void * jresult ;
38483   float arg1 ;
38484   float arg2 ;
38485   Dali::TimePeriod *result = 0 ;
38486
38487   arg1 = (float)jarg1;
38488   arg2 = (float)jarg2;
38489   {
38490     try {
38491       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
38492     } catch (std::out_of_range& e) {
38493       {
38494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38495       };
38496     } catch (std::exception& e) {
38497       {
38498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38499       };
38500     } catch (...) {
38501       {
38502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38503       };
38504     }
38505   }
38506   jresult = (void *)result;
38507   return jresult;
38508 }
38509
38510
38511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
38512   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38513
38514   arg1 = (Dali::TimePeriod *)jarg1;
38515   {
38516     try {
38517       delete arg1;
38518     } catch (std::out_of_range& e) {
38519       {
38520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38521       };
38522     } catch (std::exception& e) {
38523       {
38524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38525       };
38526     } catch (...) {
38527       {
38528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38529       };
38530     }
38531   }
38532 }
38533
38534
38535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
38536   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38537   float arg2 ;
38538
38539   arg1 = (Dali::TimePeriod *)jarg1;
38540   arg2 = (float)jarg2;
38541   if (arg1) (arg1)->delaySeconds = arg2;
38542 }
38543
38544
38545 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
38546   float jresult ;
38547   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38548   float result;
38549
38550   arg1 = (Dali::TimePeriod *)jarg1;
38551   result = (float) ((arg1)->delaySeconds);
38552   jresult = result;
38553   return jresult;
38554 }
38555
38556
38557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
38558   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38559   float arg2 ;
38560
38561   arg1 = (Dali::TimePeriod *)jarg1;
38562   arg2 = (float)jarg2;
38563   if (arg1) (arg1)->durationSeconds = arg2;
38564 }
38565
38566
38567 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
38568   float jresult ;
38569   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38570   float result;
38571
38572   arg1 = (Dali::TimePeriod *)jarg1;
38573   result = (float) ((arg1)->durationSeconds);
38574   jresult = result;
38575   return jresult;
38576 }
38577
38578
38579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_0() {
38580   void * jresult ;
38581   Dali::Animation *result = 0 ;
38582
38583   {
38584     try {
38585       result = (Dali::Animation *)new Dali::Animation();
38586     } catch (std::out_of_range& e) {
38587       {
38588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38589       };
38590     } catch (std::exception& e) {
38591       {
38592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38593       };
38594     } catch (...) {
38595       {
38596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38597       };
38598     }
38599   }
38600   jresult = (void *)result;
38601   return jresult;
38602 }
38603
38604
38605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_New(float jarg1) {
38606   void * jresult ;
38607   float arg1 ;
38608   Dali::Animation result;
38609
38610   arg1 = (float)jarg1;
38611   {
38612     try {
38613       result = Dali::Animation::New(arg1);
38614     } catch (std::out_of_range& e) {
38615       {
38616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38617       };
38618     } catch (std::exception& e) {
38619       {
38620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38621       };
38622     } catch (...) {
38623       {
38624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38625       };
38626     }
38627   }
38628   jresult = new Dali::Animation((const Dali::Animation &)result);
38629   return jresult;
38630 }
38631
38632
38633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_DownCast(void * jarg1) {
38634   void * jresult ;
38635   Dali::BaseHandle arg1 ;
38636   Dali::BaseHandle *argp1 ;
38637   Dali::Animation result;
38638
38639   argp1 = (Dali::BaseHandle *)jarg1;
38640   if (!argp1) {
38641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38642     return 0;
38643   }
38644   arg1 = *argp1;
38645   {
38646     try {
38647       result = Dali::Animation::DownCast(arg1);
38648     } catch (std::out_of_range& e) {
38649       {
38650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38651       };
38652     } catch (std::exception& e) {
38653       {
38654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38655       };
38656     } catch (...) {
38657       {
38658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38659       };
38660     }
38661   }
38662   jresult = new Dali::Animation((const Dali::Animation &)result);
38663   return jresult;
38664 }
38665
38666
38667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Animation(void * jarg1) {
38668   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38669
38670   arg1 = (Dali::Animation *)jarg1;
38671   {
38672     try {
38673       delete arg1;
38674     } catch (std::out_of_range& e) {
38675       {
38676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38677       };
38678     } catch (std::exception& e) {
38679       {
38680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38681       };
38682     } catch (...) {
38683       {
38684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38685       };
38686     }
38687   }
38688 }
38689
38690
38691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_1(void * jarg1) {
38692   void * jresult ;
38693   Dali::Animation *arg1 = 0 ;
38694   Dali::Animation *result = 0 ;
38695
38696   arg1 = (Dali::Animation *)jarg1;
38697   if (!arg1) {
38698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38699     return 0;
38700   }
38701   {
38702     try {
38703       result = (Dali::Animation *)new Dali::Animation((Dali::Animation const &)*arg1);
38704     } catch (std::out_of_range& e) {
38705       {
38706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38707       };
38708     } catch (std::exception& e) {
38709       {
38710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38711       };
38712     } catch (...) {
38713       {
38714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38715       };
38716     }
38717   }
38718   jresult = (void *)result;
38719   return jresult;
38720 }
38721
38722
38723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_Assign(void * jarg1, void * jarg2) {
38724   void * jresult ;
38725   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38726   Dali::Animation *arg2 = 0 ;
38727   Dali::Animation *result = 0 ;
38728
38729   arg1 = (Dali::Animation *)jarg1;
38730   arg2 = (Dali::Animation *)jarg2;
38731   if (!arg2) {
38732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38733     return 0;
38734   }
38735   {
38736     try {
38737       result = (Dali::Animation *) &(arg1)->operator =((Dali::Animation const &)*arg2);
38738     } catch (std::out_of_range& e) {
38739       {
38740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38741       };
38742     } catch (std::exception& e) {
38743       {
38744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38745       };
38746     } catch (...) {
38747       {
38748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38749       };
38750     }
38751   }
38752   jresult = (void *)result;
38753   return jresult;
38754 }
38755
38756
38757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDuration(void * jarg1, float jarg2) {
38758   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38759   float arg2 ;
38760
38761   arg1 = (Dali::Animation *)jarg1;
38762   arg2 = (float)jarg2;
38763   {
38764     try {
38765       (arg1)->SetDuration(arg2);
38766     } catch (std::out_of_range& e) {
38767       {
38768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38769       };
38770     } catch (std::exception& e) {
38771       {
38772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38773       };
38774     } catch (...) {
38775       {
38776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38777       };
38778     }
38779   }
38780 }
38781
38782
38783 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetDuration(void * jarg1) {
38784   float jresult ;
38785   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38786   float result;
38787
38788   arg1 = (Dali::Animation *)jarg1;
38789   {
38790     try {
38791       result = (float)((Dali::Animation const *)arg1)->GetDuration();
38792     } catch (std::out_of_range& e) {
38793       {
38794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38795       };
38796     } catch (std::exception& e) {
38797       {
38798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38799       };
38800     } catch (...) {
38801       {
38802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38803       };
38804     }
38805   }
38806   jresult = result;
38807   return jresult;
38808 }
38809
38810
38811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLooping(void * jarg1, unsigned int jarg2) {
38812   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38813   bool arg2 ;
38814
38815   arg1 = (Dali::Animation *)jarg1;
38816   arg2 = jarg2 ? true : false;
38817   {
38818     try {
38819       (arg1)->SetLooping(arg2);
38820     } catch (std::out_of_range& e) {
38821       {
38822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38823       };
38824     } catch (std::exception& e) {
38825       {
38826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38827       };
38828     } catch (...) {
38829       {
38830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38831       };
38832     }
38833   }
38834 }
38835
38836
38837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLoopCount(void * jarg1, int jarg2) {
38838   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38839   int arg2 ;
38840
38841   arg1 = (Dali::Animation *)jarg1;
38842   arg2 = (int)jarg2;
38843   {
38844     try {
38845       (arg1)->SetLoopCount(arg2);
38846     } catch (std::out_of_range& e) {
38847       {
38848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38849       };
38850     } catch (std::exception& e) {
38851       {
38852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38853       };
38854     } catch (...) {
38855       {
38856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38857       };
38858     }
38859   }
38860 }
38861
38862
38863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetLoopCount(void * jarg1) {
38864   int jresult ;
38865   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38866   int result;
38867
38868   arg1 = (Dali::Animation *)jarg1;
38869   {
38870     try {
38871       result = (int)(arg1)->GetLoopCount();
38872     } catch (std::out_of_range& e) {
38873       {
38874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38875       };
38876     } catch (std::exception& e) {
38877       {
38878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38879       };
38880     } catch (...) {
38881       {
38882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38883       };
38884     }
38885   }
38886   jresult = result;
38887   return jresult;
38888 }
38889
38890
38891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetCurrentLoop(void * jarg1) {
38892   int jresult ;
38893   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38894   int result;
38895
38896   arg1 = (Dali::Animation *)jarg1;
38897   {
38898     try {
38899       result = (int)(arg1)->GetCurrentLoop();
38900     } catch (std::out_of_range& e) {
38901       {
38902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38903       };
38904     } catch (std::exception& e) {
38905       {
38906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38907       };
38908     } catch (...) {
38909       {
38910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38911       };
38912     }
38913   }
38914   jresult = result;
38915   return jresult;
38916 }
38917
38918
38919 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Animation_IsLooping(void * jarg1) {
38920   unsigned int jresult ;
38921   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38922   bool result;
38923
38924   arg1 = (Dali::Animation *)jarg1;
38925   {
38926     try {
38927       result = (bool)((Dali::Animation const *)arg1)->IsLooping();
38928     } catch (std::out_of_range& e) {
38929       {
38930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38931       };
38932     } catch (std::exception& e) {
38933       {
38934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38935       };
38936     } catch (...) {
38937       {
38938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38939       };
38940     }
38941   }
38942   jresult = result;
38943   return jresult;
38944 }
38945
38946
38947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetEndAction(void * jarg1, int jarg2) {
38948   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38949   Dali::Animation::EndAction arg2 ;
38950
38951   arg1 = (Dali::Animation *)jarg1;
38952   arg2 = (Dali::Animation::EndAction)jarg2;
38953   {
38954     try {
38955       (arg1)->SetEndAction(arg2);
38956     } catch (std::out_of_range& e) {
38957       {
38958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38959       };
38960     } catch (std::exception& e) {
38961       {
38962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38963       };
38964     } catch (...) {
38965       {
38966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38967       };
38968     }
38969   }
38970 }
38971
38972
38973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetEndAction(void * jarg1) {
38974   int jresult ;
38975   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38976   Dali::Animation::EndAction result;
38977
38978   arg1 = (Dali::Animation *)jarg1;
38979   {
38980     try {
38981       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetEndAction();
38982     } catch (std::out_of_range& e) {
38983       {
38984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38985       };
38986     } catch (std::exception& e) {
38987       {
38988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38989       };
38990     } catch (...) {
38991       {
38992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38993       };
38994     }
38995   }
38996   jresult = (int)result;
38997   return jresult;
38998 }
38999
39000
39001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDisconnectAction(void * jarg1, int jarg2) {
39002   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39003   Dali::Animation::EndAction arg2 ;
39004
39005   arg1 = (Dali::Animation *)jarg1;
39006   arg2 = (Dali::Animation::EndAction)jarg2;
39007   {
39008     try {
39009       (arg1)->SetDisconnectAction(arg2);
39010     } catch (std::out_of_range& e) {
39011       {
39012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39013       };
39014     } catch (std::exception& e) {
39015       {
39016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39017       };
39018     } catch (...) {
39019       {
39020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39021       };
39022     }
39023   }
39024 }
39025
39026
39027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetDisconnectAction(void * jarg1) {
39028   int jresult ;
39029   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39030   Dali::Animation::EndAction result;
39031
39032   arg1 = (Dali::Animation *)jarg1;
39033   {
39034     try {
39035       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetDisconnectAction();
39036     } catch (std::out_of_range& e) {
39037       {
39038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39039       };
39040     } catch (std::exception& e) {
39041       {
39042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39043       };
39044     } catch (...) {
39045       {
39046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39047       };
39048     }
39049   }
39050   jresult = (int)result;
39051   return jresult;
39052 }
39053
39054
39055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDefaultAlphaFunction(void * jarg1, void * jarg2) {
39056   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39057   Dali::AlphaFunction arg2 ;
39058   Dali::AlphaFunction *argp2 ;
39059
39060   arg1 = (Dali::Animation *)jarg1;
39061   argp2 = (Dali::AlphaFunction *)jarg2;
39062   if (!argp2) {
39063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39064     return ;
39065   }
39066   arg2 = *argp2;
39067   {
39068     try {
39069       (arg1)->SetDefaultAlphaFunction(arg2);
39070     } catch (std::out_of_range& e) {
39071       {
39072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39073       };
39074     } catch (std::exception& e) {
39075       {
39076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39077       };
39078     } catch (...) {
39079       {
39080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39081       };
39082     }
39083   }
39084 }
39085
39086
39087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetDefaultAlphaFunction(void * jarg1) {
39088   void * jresult ;
39089   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39090   Dali::AlphaFunction result;
39091
39092   arg1 = (Dali::Animation *)jarg1;
39093   {
39094     try {
39095       result = ((Dali::Animation const *)arg1)->GetDefaultAlphaFunction();
39096     } catch (std::out_of_range& e) {
39097       {
39098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39099       };
39100     } catch (std::exception& e) {
39101       {
39102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39103       };
39104     } catch (...) {
39105       {
39106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39107       };
39108     }
39109   }
39110   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
39111   return jresult;
39112 }
39113
39114
39115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetCurrentProgress(void * jarg1, float jarg2) {
39116   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39117   float arg2 ;
39118
39119   arg1 = (Dali::Animation *)jarg1;
39120   arg2 = (float)jarg2;
39121   {
39122     try {
39123       (arg1)->SetCurrentProgress(arg2);
39124     } catch (std::out_of_range& e) {
39125       {
39126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39127       };
39128     } catch (std::exception& e) {
39129       {
39130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39131       };
39132     } catch (...) {
39133       {
39134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39135       };
39136     }
39137   }
39138 }
39139
39140
39141 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetCurrentProgress(void * jarg1) {
39142   float jresult ;
39143   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39144   float result;
39145
39146   arg1 = (Dali::Animation *)jarg1;
39147   {
39148     try {
39149       result = (float)(arg1)->GetCurrentProgress();
39150     } catch (std::out_of_range& e) {
39151       {
39152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39153       };
39154     } catch (std::exception& e) {
39155       {
39156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39157       };
39158     } catch (...) {
39159       {
39160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39161       };
39162     }
39163   }
39164   jresult = result;
39165   return jresult;
39166 }
39167
39168
39169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetSpeedFactor(void * jarg1, float jarg2) {
39170   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39171   float arg2 ;
39172
39173   arg1 = (Dali::Animation *)jarg1;
39174   arg2 = (float)jarg2;
39175   {
39176     try {
39177       (arg1)->SetSpeedFactor(arg2);
39178     } catch (std::out_of_range& e) {
39179       {
39180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39181       };
39182     } catch (std::exception& e) {
39183       {
39184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39185       };
39186     } catch (...) {
39187       {
39188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39189       };
39190     }
39191   }
39192 }
39193
39194
39195 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetSpeedFactor(void * jarg1) {
39196   float jresult ;
39197   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39198   float result;
39199
39200   arg1 = (Dali::Animation *)jarg1;
39201   {
39202     try {
39203       result = (float)((Dali::Animation const *)arg1)->GetSpeedFactor();
39204     } catch (std::out_of_range& e) {
39205       {
39206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39207       };
39208     } catch (std::exception& e) {
39209       {
39210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39211       };
39212     } catch (...) {
39213       {
39214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39215       };
39216     }
39217   }
39218   jresult = result;
39219   return jresult;
39220 }
39221
39222
39223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetPlayRange(void * jarg1, void * jarg2) {
39224   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39225   Dali::Vector2 *arg2 = 0 ;
39226
39227   arg1 = (Dali::Animation *)jarg1;
39228   arg2 = (Dali::Vector2 *)jarg2;
39229   if (!arg2) {
39230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39231     return ;
39232   }
39233   {
39234     try {
39235       (arg1)->SetPlayRange((Dali::Vector2 const &)*arg2);
39236     } catch (std::out_of_range& e) {
39237       {
39238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39239       };
39240     } catch (std::exception& e) {
39241       {
39242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39243       };
39244     } catch (...) {
39245       {
39246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39247       };
39248     }
39249   }
39250 }
39251
39252
39253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetPlayRange(void * jarg1) {
39254   void * jresult ;
39255   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39256   Dali::Vector2 result;
39257
39258   arg1 = (Dali::Animation *)jarg1;
39259   {
39260     try {
39261       result = ((Dali::Animation const *)arg1)->GetPlayRange();
39262     } catch (std::out_of_range& e) {
39263       {
39264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39265       };
39266     } catch (std::exception& e) {
39267       {
39268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39269       };
39270     } catch (...) {
39271       {
39272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39273       };
39274     }
39275   }
39276   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
39277   return jresult;
39278 }
39279
39280
39281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Play(void * jarg1) {
39282   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39283
39284   arg1 = (Dali::Animation *)jarg1;
39285   {
39286     try {
39287       (arg1)->Play();
39288     } catch (std::out_of_range& e) {
39289       {
39290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39291       };
39292     } catch (std::exception& e) {
39293       {
39294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39295       };
39296     } catch (...) {
39297       {
39298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39299       };
39300     }
39301   }
39302 }
39303
39304
39305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_PlayFrom(void * jarg1, float jarg2) {
39306   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39307   float arg2 ;
39308
39309   arg1 = (Dali::Animation *)jarg1;
39310   arg2 = (float)jarg2;
39311   {
39312     try {
39313       (arg1)->PlayFrom(arg2);
39314     } catch (std::out_of_range& e) {
39315       {
39316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39317       };
39318     } catch (std::exception& e) {
39319       {
39320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39321       };
39322     } catch (...) {
39323       {
39324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39325       };
39326     }
39327   }
39328 }
39329
39330
39331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Pause(void * jarg1) {
39332   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39333
39334   arg1 = (Dali::Animation *)jarg1;
39335   {
39336     try {
39337       (arg1)->Pause();
39338     } catch (std::out_of_range& e) {
39339       {
39340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39341       };
39342     } catch (std::exception& e) {
39343       {
39344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39345       };
39346     } catch (...) {
39347       {
39348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39349       };
39350     }
39351   }
39352 }
39353
39354
39355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetState(void * jarg1) {
39356   int jresult ;
39357   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39358   Dali::Animation::State result;
39359
39360   arg1 = (Dali::Animation *)jarg1;
39361   {
39362     try {
39363       result = (Dali::Animation::State)((Dali::Animation const *)arg1)->GetState();
39364     } catch (std::out_of_range& e) {
39365       {
39366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39367       };
39368     } catch (std::exception& e) {
39369       {
39370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39371       };
39372     } catch (...) {
39373       {
39374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39375       };
39376     }
39377   }
39378   jresult = (int)result;
39379   return jresult;
39380 }
39381
39382
39383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Stop(void * jarg1) {
39384   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39385
39386   arg1 = (Dali::Animation *)jarg1;
39387   {
39388     try {
39389       (arg1)->Stop();
39390     } catch (std::out_of_range& e) {
39391       {
39392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39393       };
39394     } catch (std::exception& e) {
39395       {
39396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39397       };
39398     } catch (...) {
39399       {
39400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39401       };
39402     }
39403   }
39404 }
39405
39406
39407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Clear(void * jarg1) {
39408   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39409
39410   arg1 = (Dali::Animation *)jarg1;
39411   {
39412     try {
39413       (arg1)->Clear();
39414     } catch (std::out_of_range& e) {
39415       {
39416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39417       };
39418     } catch (std::exception& e) {
39419       {
39420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39421       };
39422     } catch (...) {
39423       {
39424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39425       };
39426     }
39427   }
39428 }
39429
39430
39431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_FinishedSignal(void * jarg1) {
39432   void * jresult ;
39433   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39434   Dali::Animation::AnimationSignalType *result = 0 ;
39435
39436   arg1 = (Dali::Animation *)jarg1;
39437   {
39438     try {
39439       result = (Dali::Animation::AnimationSignalType *) &(arg1)->FinishedSignal();
39440     } catch (std::out_of_range& e) {
39441       {
39442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39443       };
39444     } catch (std::exception& e) {
39445       {
39446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39447       };
39448     } catch (...) {
39449       {
39450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39451       };
39452     }
39453   }
39454   jresult = (void *)result;
39455   return jresult;
39456 }
39457
39458
39459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39460   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39461   SwigValueWrapper< Dali::Property > arg2 ;
39462   Dali::Property::Value arg3 ;
39463   Dali::Property *argp2 ;
39464   Dali::Property::Value *argp3 ;
39465
39466   arg1 = (Dali::Animation *)jarg1;
39467   argp2 = (Dali::Property *)jarg2;
39468   if (!argp2) {
39469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39470     return ;
39471   }
39472   arg2 = *argp2;
39473   argp3 = (Dali::Property::Value *)jarg3;
39474   if (!argp3) {
39475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39476     return ;
39477   }
39478   arg3 = *argp3;
39479   {
39480     try {
39481       (arg1)->AnimateBy(arg2,arg3);
39482     } catch (std::out_of_range& e) {
39483       {
39484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39485       };
39486     } catch (std::exception& e) {
39487       {
39488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39489       };
39490     } catch (...) {
39491       {
39492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39493       };
39494     }
39495   }
39496 }
39497
39498
39499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39500   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39501   SwigValueWrapper< Dali::Property > arg2 ;
39502   Dali::Property::Value arg3 ;
39503   Dali::AlphaFunction arg4 ;
39504   Dali::Property *argp2 ;
39505   Dali::Property::Value *argp3 ;
39506   Dali::AlphaFunction *argp4 ;
39507
39508   arg1 = (Dali::Animation *)jarg1;
39509   argp2 = (Dali::Property *)jarg2;
39510   if (!argp2) {
39511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39512     return ;
39513   }
39514   arg2 = *argp2;
39515   argp3 = (Dali::Property::Value *)jarg3;
39516   if (!argp3) {
39517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39518     return ;
39519   }
39520   arg3 = *argp3;
39521   argp4 = (Dali::AlphaFunction *)jarg4;
39522   if (!argp4) {
39523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39524     return ;
39525   }
39526   arg4 = *argp4;
39527   {
39528     try {
39529       (arg1)->AnimateBy(arg2,arg3,arg4);
39530     } catch (std::out_of_range& e) {
39531       {
39532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39533       };
39534     } catch (std::exception& e) {
39535       {
39536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39537       };
39538     } catch (...) {
39539       {
39540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39541       };
39542     }
39543   }
39544 }
39545
39546
39547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39548   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39549   SwigValueWrapper< Dali::Property > arg2 ;
39550   Dali::Property::Value arg3 ;
39551   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39552   Dali::Property *argp2 ;
39553   Dali::Property::Value *argp3 ;
39554   Dali::TimePeriod *argp4 ;
39555
39556   arg1 = (Dali::Animation *)jarg1;
39557   argp2 = (Dali::Property *)jarg2;
39558   if (!argp2) {
39559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39560     return ;
39561   }
39562   arg2 = *argp2;
39563   argp3 = (Dali::Property::Value *)jarg3;
39564   if (!argp3) {
39565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39566     return ;
39567   }
39568   arg3 = *argp3;
39569   argp4 = (Dali::TimePeriod *)jarg4;
39570   if (!argp4) {
39571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39572     return ;
39573   }
39574   arg4 = *argp4;
39575   {
39576     try {
39577       (arg1)->AnimateBy(arg2,arg3,arg4);
39578     } catch (std::out_of_range& e) {
39579       {
39580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39581       };
39582     } catch (std::exception& e) {
39583       {
39584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39585       };
39586     } catch (...) {
39587       {
39588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39589       };
39590     }
39591   }
39592 }
39593
39594
39595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39596   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39597   SwigValueWrapper< Dali::Property > arg2 ;
39598   Dali::Property::Value arg3 ;
39599   Dali::AlphaFunction arg4 ;
39600   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39601   Dali::Property *argp2 ;
39602   Dali::Property::Value *argp3 ;
39603   Dali::AlphaFunction *argp4 ;
39604   Dali::TimePeriod *argp5 ;
39605
39606   arg1 = (Dali::Animation *)jarg1;
39607   argp2 = (Dali::Property *)jarg2;
39608   if (!argp2) {
39609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39610     return ;
39611   }
39612   arg2 = *argp2;
39613   argp3 = (Dali::Property::Value *)jarg3;
39614   if (!argp3) {
39615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39616     return ;
39617   }
39618   arg3 = *argp3;
39619   argp4 = (Dali::AlphaFunction *)jarg4;
39620   if (!argp4) {
39621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39622     return ;
39623   }
39624   arg4 = *argp4;
39625   argp5 = (Dali::TimePeriod *)jarg5;
39626   if (!argp5) {
39627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39628     return ;
39629   }
39630   arg5 = *argp5;
39631   {
39632     try {
39633       (arg1)->AnimateBy(arg2,arg3,arg4,arg5);
39634     } catch (std::out_of_range& e) {
39635       {
39636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39637       };
39638     } catch (std::exception& e) {
39639       {
39640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39641       };
39642     } catch (...) {
39643       {
39644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39645       };
39646     }
39647   }
39648 }
39649
39650
39651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39652   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39653   SwigValueWrapper< Dali::Property > arg2 ;
39654   Dali::Property::Value arg3 ;
39655   Dali::Property *argp2 ;
39656   Dali::Property::Value *argp3 ;
39657
39658   arg1 = (Dali::Animation *)jarg1;
39659   argp2 = (Dali::Property *)jarg2;
39660   if (!argp2) {
39661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39662     return ;
39663   }
39664   arg2 = *argp2;
39665   argp3 = (Dali::Property::Value *)jarg3;
39666   if (!argp3) {
39667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39668     return ;
39669   }
39670   arg3 = *argp3;
39671   {
39672     try {
39673       (arg1)->AnimateTo(arg2,arg3);
39674     } catch (std::out_of_range& e) {
39675       {
39676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39677       };
39678     } catch (std::exception& e) {
39679       {
39680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39681       };
39682     } catch (...) {
39683       {
39684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39685       };
39686     }
39687   }
39688 }
39689
39690
39691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39692   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39693   SwigValueWrapper< Dali::Property > arg2 ;
39694   Dali::Property::Value arg3 ;
39695   Dali::AlphaFunction arg4 ;
39696   Dali::Property *argp2 ;
39697   Dali::Property::Value *argp3 ;
39698   Dali::AlphaFunction *argp4 ;
39699
39700   arg1 = (Dali::Animation *)jarg1;
39701   argp2 = (Dali::Property *)jarg2;
39702   if (!argp2) {
39703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39704     return ;
39705   }
39706   arg2 = *argp2;
39707   argp3 = (Dali::Property::Value *)jarg3;
39708   if (!argp3) {
39709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39710     return ;
39711   }
39712   arg3 = *argp3;
39713   argp4 = (Dali::AlphaFunction *)jarg4;
39714   if (!argp4) {
39715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39716     return ;
39717   }
39718   arg4 = *argp4;
39719   {
39720     try {
39721       (arg1)->AnimateTo(arg2,arg3,arg4);
39722     } catch (std::out_of_range& e) {
39723       {
39724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39725       };
39726     } catch (std::exception& e) {
39727       {
39728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39729       };
39730     } catch (...) {
39731       {
39732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39733       };
39734     }
39735   }
39736 }
39737
39738
39739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39740   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39741   SwigValueWrapper< Dali::Property > arg2 ;
39742   Dali::Property::Value arg3 ;
39743   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39744   Dali::Property *argp2 ;
39745   Dali::Property::Value *argp3 ;
39746   Dali::TimePeriod *argp4 ;
39747
39748   arg1 = (Dali::Animation *)jarg1;
39749   argp2 = (Dali::Property *)jarg2;
39750   if (!argp2) {
39751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39752     return ;
39753   }
39754   arg2 = *argp2;
39755   argp3 = (Dali::Property::Value *)jarg3;
39756   if (!argp3) {
39757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39758     return ;
39759   }
39760   arg3 = *argp3;
39761   argp4 = (Dali::TimePeriod *)jarg4;
39762   if (!argp4) {
39763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39764     return ;
39765   }
39766   arg4 = *argp4;
39767   {
39768     try {
39769       (arg1)->AnimateTo(arg2,arg3,arg4);
39770     } catch (std::out_of_range& e) {
39771       {
39772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39773       };
39774     } catch (std::exception& e) {
39775       {
39776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39777       };
39778     } catch (...) {
39779       {
39780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39781       };
39782     }
39783   }
39784 }
39785
39786
39787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39788   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39789   SwigValueWrapper< Dali::Property > arg2 ;
39790   Dali::Property::Value arg3 ;
39791   Dali::AlphaFunction arg4 ;
39792   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39793   Dali::Property *argp2 ;
39794   Dali::Property::Value *argp3 ;
39795   Dali::AlphaFunction *argp4 ;
39796   Dali::TimePeriod *argp5 ;
39797
39798   arg1 = (Dali::Animation *)jarg1;
39799   argp2 = (Dali::Property *)jarg2;
39800   if (!argp2) {
39801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39802     return ;
39803   }
39804   arg2 = *argp2;
39805   argp3 = (Dali::Property::Value *)jarg3;
39806   if (!argp3) {
39807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39808     return ;
39809   }
39810   arg3 = *argp3;
39811   argp4 = (Dali::AlphaFunction *)jarg4;
39812   if (!argp4) {
39813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39814     return ;
39815   }
39816   arg4 = *argp4;
39817   argp5 = (Dali::TimePeriod *)jarg5;
39818   if (!argp5) {
39819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39820     return ;
39821   }
39822   arg5 = *argp5;
39823   {
39824     try {
39825       (arg1)->AnimateTo(arg2,arg3,arg4,arg5);
39826     } catch (std::out_of_range& e) {
39827       {
39828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39829       };
39830     } catch (std::exception& e) {
39831       {
39832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39833       };
39834     } catch (...) {
39835       {
39836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39837       };
39838     }
39839   }
39840 }
39841
39842
39843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39844   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39845   SwigValueWrapper< Dali::Property > arg2 ;
39846   Dali::KeyFrames *arg3 = 0 ;
39847   Dali::Property *argp2 ;
39848
39849   arg1 = (Dali::Animation *)jarg1;
39850   argp2 = (Dali::Property *)jarg2;
39851   if (!argp2) {
39852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39853     return ;
39854   }
39855   arg2 = *argp2;
39856   arg3 = (Dali::KeyFrames *)jarg3;
39857   if (!arg3) {
39858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39859     return ;
39860   }
39861   {
39862     try {
39863       (arg1)->AnimateBetween(arg2,*arg3);
39864     } catch (std::out_of_range& e) {
39865       {
39866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39867       };
39868     } catch (std::exception& e) {
39869       {
39870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39871       };
39872     } catch (...) {
39873       {
39874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39875       };
39876     }
39877   }
39878 }
39879
39880
39881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_1(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
39882   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39883   SwigValueWrapper< Dali::Property > arg2 ;
39884   Dali::KeyFrames *arg3 = 0 ;
39885   Dali::Animation::Interpolation arg4 ;
39886   Dali::Property *argp2 ;
39887
39888   arg1 = (Dali::Animation *)jarg1;
39889   argp2 = (Dali::Property *)jarg2;
39890   if (!argp2) {
39891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39892     return ;
39893   }
39894   arg2 = *argp2;
39895   arg3 = (Dali::KeyFrames *)jarg3;
39896   if (!arg3) {
39897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39898     return ;
39899   }
39900   arg4 = (Dali::Animation::Interpolation)jarg4;
39901   {
39902     try {
39903       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39904     } catch (std::out_of_range& e) {
39905       {
39906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39907       };
39908     } catch (std::exception& e) {
39909       {
39910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39911       };
39912     } catch (...) {
39913       {
39914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39915       };
39916     }
39917   }
39918 }
39919
39920
39921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39922   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39923   SwigValueWrapper< Dali::Property > arg2 ;
39924   Dali::KeyFrames *arg3 = 0 ;
39925   Dali::AlphaFunction arg4 ;
39926   Dali::Property *argp2 ;
39927   Dali::AlphaFunction *argp4 ;
39928
39929   arg1 = (Dali::Animation *)jarg1;
39930   argp2 = (Dali::Property *)jarg2;
39931   if (!argp2) {
39932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39933     return ;
39934   }
39935   arg2 = *argp2;
39936   arg3 = (Dali::KeyFrames *)jarg3;
39937   if (!arg3) {
39938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39939     return ;
39940   }
39941   argp4 = (Dali::AlphaFunction *)jarg4;
39942   if (!argp4) {
39943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39944     return ;
39945   }
39946   arg4 = *argp4;
39947   {
39948     try {
39949       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39950     } catch (std::out_of_range& e) {
39951       {
39952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39953       };
39954     } catch (std::exception& e) {
39955       {
39956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39957       };
39958     } catch (...) {
39959       {
39960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39961       };
39962     }
39963   }
39964 }
39965
39966
39967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
39968   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39969   SwigValueWrapper< Dali::Property > arg2 ;
39970   Dali::KeyFrames *arg3 = 0 ;
39971   Dali::AlphaFunction arg4 ;
39972   Dali::Animation::Interpolation arg5 ;
39973   Dali::Property *argp2 ;
39974   Dali::AlphaFunction *argp4 ;
39975
39976   arg1 = (Dali::Animation *)jarg1;
39977   argp2 = (Dali::Property *)jarg2;
39978   if (!argp2) {
39979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39980     return ;
39981   }
39982   arg2 = *argp2;
39983   arg3 = (Dali::KeyFrames *)jarg3;
39984   if (!arg3) {
39985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39986     return ;
39987   }
39988   argp4 = (Dali::AlphaFunction *)jarg4;
39989   if (!argp4) {
39990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39991     return ;
39992   }
39993   arg4 = *argp4;
39994   arg5 = (Dali::Animation::Interpolation)jarg5;
39995   {
39996     try {
39997       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
39998     } catch (std::out_of_range& e) {
39999       {
40000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40001       };
40002     } catch (std::exception& e) {
40003       {
40004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40005       };
40006     } catch (...) {
40007       {
40008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40009       };
40010     }
40011   }
40012 }
40013
40014
40015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40016   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40017   SwigValueWrapper< Dali::Property > arg2 ;
40018   Dali::KeyFrames *arg3 = 0 ;
40019   SwigValueWrapper< Dali::TimePeriod > arg4 ;
40020   Dali::Property *argp2 ;
40021   Dali::TimePeriod *argp4 ;
40022
40023   arg1 = (Dali::Animation *)jarg1;
40024   argp2 = (Dali::Property *)jarg2;
40025   if (!argp2) {
40026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40027     return ;
40028   }
40029   arg2 = *argp2;
40030   arg3 = (Dali::KeyFrames *)jarg3;
40031   if (!arg3) {
40032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40033     return ;
40034   }
40035   argp4 = (Dali::TimePeriod *)jarg4;
40036   if (!argp4) {
40037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40038     return ;
40039   }
40040   arg4 = *argp4;
40041   {
40042     try {
40043       (arg1)->AnimateBetween(arg2,*arg3,arg4);
40044     } catch (std::out_of_range& e) {
40045       {
40046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40047       };
40048     } catch (std::exception& e) {
40049       {
40050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40051       };
40052     } catch (...) {
40053       {
40054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40055       };
40056     }
40057   }
40058 }
40059
40060
40061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
40062   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40063   SwigValueWrapper< Dali::Property > arg2 ;
40064   Dali::KeyFrames *arg3 = 0 ;
40065   SwigValueWrapper< Dali::TimePeriod > arg4 ;
40066   Dali::Animation::Interpolation arg5 ;
40067   Dali::Property *argp2 ;
40068   Dali::TimePeriod *argp4 ;
40069
40070   arg1 = (Dali::Animation *)jarg1;
40071   argp2 = (Dali::Property *)jarg2;
40072   if (!argp2) {
40073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40074     return ;
40075   }
40076   arg2 = *argp2;
40077   arg3 = (Dali::KeyFrames *)jarg3;
40078   if (!arg3) {
40079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40080     return ;
40081   }
40082   argp4 = (Dali::TimePeriod *)jarg4;
40083   if (!argp4) {
40084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40085     return ;
40086   }
40087   arg4 = *argp4;
40088   arg5 = (Dali::Animation::Interpolation)jarg5;
40089   {
40090     try {
40091       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
40092     } catch (std::out_of_range& e) {
40093       {
40094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40095       };
40096     } catch (std::exception& e) {
40097       {
40098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40099       };
40100     } catch (...) {
40101       {
40102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40103       };
40104     }
40105   }
40106 }
40107
40108
40109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40110   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40111   SwigValueWrapper< Dali::Property > arg2 ;
40112   Dali::KeyFrames *arg3 = 0 ;
40113   Dali::AlphaFunction arg4 ;
40114   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40115   Dali::Property *argp2 ;
40116   Dali::AlphaFunction *argp4 ;
40117   Dali::TimePeriod *argp5 ;
40118
40119   arg1 = (Dali::Animation *)jarg1;
40120   argp2 = (Dali::Property *)jarg2;
40121   if (!argp2) {
40122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40123     return ;
40124   }
40125   arg2 = *argp2;
40126   arg3 = (Dali::KeyFrames *)jarg3;
40127   if (!arg3) {
40128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40129     return ;
40130   }
40131   argp4 = (Dali::AlphaFunction *)jarg4;
40132   if (!argp4) {
40133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40134     return ;
40135   }
40136   arg4 = *argp4;
40137   argp5 = (Dali::TimePeriod *)jarg5;
40138   if (!argp5) {
40139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40140     return ;
40141   }
40142   arg5 = *argp5;
40143   {
40144     try {
40145       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
40146     } catch (std::out_of_range& e) {
40147       {
40148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40149       };
40150     } catch (std::exception& e) {
40151       {
40152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40153       };
40154     } catch (...) {
40155       {
40156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40157       };
40158     }
40159   }
40160 }
40161
40162
40163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_7(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
40164   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40165   SwigValueWrapper< Dali::Property > arg2 ;
40166   Dali::KeyFrames *arg3 = 0 ;
40167   Dali::AlphaFunction arg4 ;
40168   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40169   Dali::Animation::Interpolation arg6 ;
40170   Dali::Property *argp2 ;
40171   Dali::AlphaFunction *argp4 ;
40172   Dali::TimePeriod *argp5 ;
40173
40174   arg1 = (Dali::Animation *)jarg1;
40175   argp2 = (Dali::Property *)jarg2;
40176   if (!argp2) {
40177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40178     return ;
40179   }
40180   arg2 = *argp2;
40181   arg3 = (Dali::KeyFrames *)jarg3;
40182   if (!arg3) {
40183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40184     return ;
40185   }
40186   argp4 = (Dali::AlphaFunction *)jarg4;
40187   if (!argp4) {
40188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40189     return ;
40190   }
40191   arg4 = *argp4;
40192   argp5 = (Dali::TimePeriod *)jarg5;
40193   if (!argp5) {
40194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40195     return ;
40196   }
40197   arg5 = *argp5;
40198   arg6 = (Dali::Animation::Interpolation)jarg6;
40199   {
40200     try {
40201       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5,arg6);
40202     } catch (std::out_of_range& e) {
40203       {
40204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40205       };
40206     } catch (std::exception& e) {
40207       {
40208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40209       };
40210     } catch (...) {
40211       {
40212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40213       };
40214     }
40215   }
40216 }
40217
40218
40219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40220   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40221   Dali::Actor arg2 ;
40222   Dali::Path arg3 ;
40223   Dali::Vector3 *arg4 = 0 ;
40224   Dali::Actor *argp2 ;
40225   Dali::Path *argp3 ;
40226
40227   arg1 = (Dali::Animation *)jarg1;
40228   argp2 = (Dali::Actor *)jarg2;
40229   if (!argp2) {
40230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40231     return ;
40232   }
40233   arg2 = *argp2;
40234   argp3 = (Dali::Path *)jarg3;
40235   if (!argp3) {
40236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40237     return ;
40238   }
40239   arg3 = *argp3;
40240   arg4 = (Dali::Vector3 *)jarg4;
40241   if (!arg4) {
40242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40243     return ;
40244   }
40245   {
40246     try {
40247       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4);
40248     } catch (std::out_of_range& e) {
40249       {
40250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40251       };
40252     } catch (std::exception& e) {
40253       {
40254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40255       };
40256     } catch (...) {
40257       {
40258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40259       };
40260     }
40261   }
40262 }
40263
40264
40265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40266   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40267   Dali::Actor arg2 ;
40268   Dali::Path arg3 ;
40269   Dali::Vector3 *arg4 = 0 ;
40270   Dali::AlphaFunction arg5 ;
40271   Dali::Actor *argp2 ;
40272   Dali::Path *argp3 ;
40273   Dali::AlphaFunction *argp5 ;
40274
40275   arg1 = (Dali::Animation *)jarg1;
40276   argp2 = (Dali::Actor *)jarg2;
40277   if (!argp2) {
40278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40279     return ;
40280   }
40281   arg2 = *argp2;
40282   argp3 = (Dali::Path *)jarg3;
40283   if (!argp3) {
40284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40285     return ;
40286   }
40287   arg3 = *argp3;
40288   arg4 = (Dali::Vector3 *)jarg4;
40289   if (!arg4) {
40290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40291     return ;
40292   }
40293   argp5 = (Dali::AlphaFunction *)jarg5;
40294   if (!argp5) {
40295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40296     return ;
40297   }
40298   arg5 = *argp5;
40299   {
40300     try {
40301       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
40302     } catch (std::out_of_range& e) {
40303       {
40304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40305       };
40306     } catch (std::exception& e) {
40307       {
40308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40309       };
40310     } catch (...) {
40311       {
40312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40313       };
40314     }
40315   }
40316 }
40317
40318
40319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40320   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40321   Dali::Actor arg2 ;
40322   Dali::Path arg3 ;
40323   Dali::Vector3 *arg4 = 0 ;
40324   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40325   Dali::Actor *argp2 ;
40326   Dali::Path *argp3 ;
40327   Dali::TimePeriod *argp5 ;
40328
40329   arg1 = (Dali::Animation *)jarg1;
40330   argp2 = (Dali::Actor *)jarg2;
40331   if (!argp2) {
40332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40333     return ;
40334   }
40335   arg2 = *argp2;
40336   argp3 = (Dali::Path *)jarg3;
40337   if (!argp3) {
40338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40339     return ;
40340   }
40341   arg3 = *argp3;
40342   arg4 = (Dali::Vector3 *)jarg4;
40343   if (!arg4) {
40344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40345     return ;
40346   }
40347   argp5 = (Dali::TimePeriod *)jarg5;
40348   if (!argp5) {
40349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40350     return ;
40351   }
40352   arg5 = *argp5;
40353   {
40354     try {
40355       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
40356     } catch (std::out_of_range& e) {
40357       {
40358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40359       };
40360     } catch (std::exception& e) {
40361       {
40362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40363       };
40364     } catch (...) {
40365       {
40366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40367       };
40368     }
40369   }
40370 }
40371
40372
40373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
40374   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40375   Dali::Actor arg2 ;
40376   Dali::Path arg3 ;
40377   Dali::Vector3 *arg4 = 0 ;
40378   Dali::AlphaFunction arg5 ;
40379   SwigValueWrapper< Dali::TimePeriod > arg6 ;
40380   Dali::Actor *argp2 ;
40381   Dali::Path *argp3 ;
40382   Dali::AlphaFunction *argp5 ;
40383   Dali::TimePeriod *argp6 ;
40384
40385   arg1 = (Dali::Animation *)jarg1;
40386   argp2 = (Dali::Actor *)jarg2;
40387   if (!argp2) {
40388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40389     return ;
40390   }
40391   arg2 = *argp2;
40392   argp3 = (Dali::Path *)jarg3;
40393   if (!argp3) {
40394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40395     return ;
40396   }
40397   arg3 = *argp3;
40398   arg4 = (Dali::Vector3 *)jarg4;
40399   if (!arg4) {
40400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40401     return ;
40402   }
40403   argp5 = (Dali::AlphaFunction *)jarg5;
40404   if (!argp5) {
40405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40406     return ;
40407   }
40408   arg5 = *argp5;
40409   argp6 = (Dali::TimePeriod *)jarg6;
40410   if (!argp6) {
40411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40412     return ;
40413   }
40414   arg6 = *argp6;
40415   {
40416     try {
40417       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5,arg6);
40418     } catch (std::out_of_range& e) {
40419       {
40420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40421       };
40422     } catch (std::exception& e) {
40423       {
40424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40425       };
40426     } catch (...) {
40427       {
40428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40429       };
40430     }
40431   }
40432 }
40433
40434
40435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Show(void * jarg1, void * jarg2, float jarg3) {
40436   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40437   Dali::Actor arg2 ;
40438   float arg3 ;
40439   Dali::Actor *argp2 ;
40440
40441   arg1 = (Dali::Animation *)jarg1;
40442   argp2 = (Dali::Actor *)jarg2;
40443   if (!argp2) {
40444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40445     return ;
40446   }
40447   arg2 = *argp2;
40448   arg3 = (float)jarg3;
40449   {
40450     try {
40451       (arg1)->Show(arg2,arg3);
40452     } catch (std::out_of_range& e) {
40453       {
40454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40455       };
40456     } catch (std::exception& e) {
40457       {
40458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40459       };
40460     } catch (...) {
40461       {
40462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40463       };
40464     }
40465   }
40466 }
40467
40468
40469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Hide(void * jarg1, void * jarg2, float jarg3) {
40470   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40471   Dali::Actor arg2 ;
40472   float arg3 ;
40473   Dali::Actor *argp2 ;
40474
40475   arg1 = (Dali::Animation *)jarg1;
40476   argp2 = (Dali::Actor *)jarg2;
40477   if (!argp2) {
40478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40479     return ;
40480   }
40481   arg2 = *argp2;
40482   arg3 = (float)jarg3;
40483   {
40484     try {
40485       (arg1)->Hide(arg2,arg3);
40486     } catch (std::out_of_range& e) {
40487       {
40488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40489       };
40490     } catch (std::exception& e) {
40491       {
40492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40493       };
40494     } catch (...) {
40495       {
40496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40497       };
40498     }
40499   }
40500 }
40501
40502
40503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
40504   int jresult ;
40505   int result;
40506
40507   result = (int)Dali::LinearConstrainer::Property::VALUE;
40508   jresult = (int)result;
40509   return jresult;
40510 }
40511
40512
40513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
40514   int jresult ;
40515   int result;
40516
40517   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
40518   jresult = (int)result;
40519   return jresult;
40520 }
40521
40522
40523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
40524   void * jresult ;
40525   Dali::LinearConstrainer::Property *result = 0 ;
40526
40527   {
40528     try {
40529       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
40530     } catch (std::out_of_range& e) {
40531       {
40532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40533       };
40534     } catch (std::exception& e) {
40535       {
40536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40537       };
40538     } catch (...) {
40539       {
40540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40541       };
40542     }
40543   }
40544   jresult = (void *)result;
40545   return jresult;
40546 }
40547
40548
40549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
40550   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
40551
40552   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
40553   {
40554     try {
40555       delete arg1;
40556     } catch (std::out_of_range& e) {
40557       {
40558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40559       };
40560     } catch (std::exception& e) {
40561       {
40562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40563       };
40564     } catch (...) {
40565       {
40566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40567       };
40568     }
40569   }
40570 }
40571
40572
40573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
40574   void * jresult ;
40575   Dali::LinearConstrainer result;
40576
40577   {
40578     try {
40579       result = Dali::LinearConstrainer::New();
40580     } catch (std::out_of_range& e) {
40581       {
40582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40583       };
40584     } catch (std::exception& e) {
40585       {
40586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40587       };
40588     } catch (...) {
40589       {
40590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40591       };
40592     }
40593   }
40594   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40595   return jresult;
40596 }
40597
40598
40599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
40600   void * jresult ;
40601   Dali::BaseHandle arg1 ;
40602   Dali::BaseHandle *argp1 ;
40603   Dali::LinearConstrainer result;
40604
40605   argp1 = (Dali::BaseHandle *)jarg1;
40606   if (!argp1) {
40607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40608     return 0;
40609   }
40610   arg1 = *argp1;
40611   {
40612     try {
40613       result = Dali::LinearConstrainer::DownCast(arg1);
40614     } catch (std::out_of_range& e) {
40615       {
40616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40617       };
40618     } catch (std::exception& e) {
40619       {
40620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40621       };
40622     } catch (...) {
40623       {
40624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40625       };
40626     }
40627   }
40628   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40629   return jresult;
40630 }
40631
40632
40633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
40634   void * jresult ;
40635   Dali::LinearConstrainer *result = 0 ;
40636
40637   {
40638     try {
40639       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
40640     } catch (std::out_of_range& e) {
40641       {
40642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40643       };
40644     } catch (std::exception& e) {
40645       {
40646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40647       };
40648     } catch (...) {
40649       {
40650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40651       };
40652     }
40653   }
40654   jresult = (void *)result;
40655   return jresult;
40656 }
40657
40658
40659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
40660   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40661
40662   arg1 = (Dali::LinearConstrainer *)jarg1;
40663   {
40664     try {
40665       delete arg1;
40666     } catch (std::out_of_range& e) {
40667       {
40668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40669       };
40670     } catch (std::exception& e) {
40671       {
40672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40673       };
40674     } catch (...) {
40675       {
40676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40677       };
40678     }
40679   }
40680 }
40681
40682
40683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
40684   void * jresult ;
40685   Dali::LinearConstrainer *arg1 = 0 ;
40686   Dali::LinearConstrainer *result = 0 ;
40687
40688   arg1 = (Dali::LinearConstrainer *)jarg1;
40689   if (!arg1) {
40690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40691     return 0;
40692   }
40693   {
40694     try {
40695       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
40696     } catch (std::out_of_range& e) {
40697       {
40698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40699       };
40700     } catch (std::exception& e) {
40701       {
40702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40703       };
40704     } catch (...) {
40705       {
40706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40707       };
40708     }
40709   }
40710   jresult = (void *)result;
40711   return jresult;
40712 }
40713
40714
40715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
40716   void * jresult ;
40717   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40718   Dali::LinearConstrainer *arg2 = 0 ;
40719   Dali::LinearConstrainer *result = 0 ;
40720
40721   arg1 = (Dali::LinearConstrainer *)jarg1;
40722   arg2 = (Dali::LinearConstrainer *)jarg2;
40723   if (!arg2) {
40724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40725     return 0;
40726   }
40727   {
40728     try {
40729       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
40730     } catch (std::out_of_range& e) {
40731       {
40732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40733       };
40734     } catch (std::exception& e) {
40735       {
40736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40737       };
40738     } catch (...) {
40739       {
40740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40741       };
40742     }
40743   }
40744   jresult = (void *)result;
40745   return jresult;
40746 }
40747
40748
40749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40750   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40751   SwigValueWrapper< Dali::Property > arg2 ;
40752   SwigValueWrapper< Dali::Property > arg3 ;
40753   Dali::Vector2 *arg4 = 0 ;
40754   Dali::Vector2 *arg5 = 0 ;
40755   Dali::Property *argp2 ;
40756   Dali::Property *argp3 ;
40757
40758   arg1 = (Dali::LinearConstrainer *)jarg1;
40759   argp2 = (Dali::Property *)jarg2;
40760   if (!argp2) {
40761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40762     return ;
40763   }
40764   arg2 = *argp2;
40765   argp3 = (Dali::Property *)jarg3;
40766   if (!argp3) {
40767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40768     return ;
40769   }
40770   arg3 = *argp3;
40771   arg4 = (Dali::Vector2 *)jarg4;
40772   if (!arg4) {
40773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40774     return ;
40775   }
40776   arg5 = (Dali::Vector2 *)jarg5;
40777   if (!arg5) {
40778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40779     return ;
40780   }
40781   {
40782     try {
40783       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
40784     } catch (std::out_of_range& e) {
40785       {
40786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40787       };
40788     } catch (std::exception& e) {
40789       {
40790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40791       };
40792     } catch (...) {
40793       {
40794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40795       };
40796     }
40797   }
40798 }
40799
40800
40801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40802   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40803   SwigValueWrapper< Dali::Property > arg2 ;
40804   SwigValueWrapper< Dali::Property > arg3 ;
40805   Dali::Vector2 *arg4 = 0 ;
40806   Dali::Property *argp2 ;
40807   Dali::Property *argp3 ;
40808
40809   arg1 = (Dali::LinearConstrainer *)jarg1;
40810   argp2 = (Dali::Property *)jarg2;
40811   if (!argp2) {
40812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40813     return ;
40814   }
40815   arg2 = *argp2;
40816   argp3 = (Dali::Property *)jarg3;
40817   if (!argp3) {
40818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40819     return ;
40820   }
40821   arg3 = *argp3;
40822   arg4 = (Dali::Vector2 *)jarg4;
40823   if (!arg4) {
40824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40825     return ;
40826   }
40827   {
40828     try {
40829       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
40830     } catch (std::out_of_range& e) {
40831       {
40832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40833       };
40834     } catch (std::exception& e) {
40835       {
40836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40837       };
40838     } catch (...) {
40839       {
40840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40841       };
40842     }
40843   }
40844 }
40845
40846
40847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
40848   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40849   Dali::Handle *arg2 = 0 ;
40850
40851   arg1 = (Dali::LinearConstrainer *)jarg1;
40852   arg2 = (Dali::Handle *)jarg2;
40853   if (!arg2) {
40854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
40855     return ;
40856   }
40857   {
40858     try {
40859       (arg1)->Remove(*arg2);
40860     } catch (std::out_of_range& e) {
40861       {
40862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40863       };
40864     } catch (std::exception& e) {
40865       {
40866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40867       };
40868     } catch (...) {
40869       {
40870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40871       };
40872     }
40873   }
40874 }
40875
40876
40877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
40878   int jresult ;
40879   int result;
40880
40881   result = (int)Dali::PathConstrainer::Property::FORWARD;
40882   jresult = (int)result;
40883   return jresult;
40884 }
40885
40886
40887 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
40888   int jresult ;
40889   int result;
40890
40891   result = (int)Dali::PathConstrainer::Property::POINTS;
40892   jresult = (int)result;
40893   return jresult;
40894 }
40895
40896
40897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
40898   int jresult ;
40899   int result;
40900
40901   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
40902   jresult = (int)result;
40903   return jresult;
40904 }
40905
40906
40907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
40908   void * jresult ;
40909   Dali::PathConstrainer::Property *result = 0 ;
40910
40911   {
40912     try {
40913       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
40914     } catch (std::out_of_range& e) {
40915       {
40916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40917       };
40918     } catch (std::exception& e) {
40919       {
40920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40921       };
40922     } catch (...) {
40923       {
40924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40925       };
40926     }
40927   }
40928   jresult = (void *)result;
40929   return jresult;
40930 }
40931
40932
40933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
40934   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
40935
40936   arg1 = (Dali::PathConstrainer::Property *)jarg1;
40937   {
40938     try {
40939       delete arg1;
40940     } catch (std::out_of_range& e) {
40941       {
40942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40943       };
40944     } catch (std::exception& e) {
40945       {
40946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40947       };
40948     } catch (...) {
40949       {
40950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40951       };
40952     }
40953   }
40954 }
40955
40956
40957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
40958   void * jresult ;
40959   Dali::PathConstrainer result;
40960
40961   {
40962     try {
40963       result = Dali::PathConstrainer::New();
40964     } catch (std::out_of_range& e) {
40965       {
40966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40967       };
40968     } catch (std::exception& e) {
40969       {
40970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40971       };
40972     } catch (...) {
40973       {
40974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40975       };
40976     }
40977   }
40978   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
40979   return jresult;
40980 }
40981
40982
40983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
40984   void * jresult ;
40985   Dali::BaseHandle arg1 ;
40986   Dali::BaseHandle *argp1 ;
40987   Dali::PathConstrainer result;
40988
40989   argp1 = (Dali::BaseHandle *)jarg1;
40990   if (!argp1) {
40991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40992     return 0;
40993   }
40994   arg1 = *argp1;
40995   {
40996     try {
40997       result = Dali::PathConstrainer::DownCast(arg1);
40998     } catch (std::out_of_range& e) {
40999       {
41000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41001       };
41002     } catch (std::exception& e) {
41003       {
41004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41005       };
41006     } catch (...) {
41007       {
41008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41009       };
41010     }
41011   }
41012   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
41013   return jresult;
41014 }
41015
41016
41017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
41018   void * jresult ;
41019   Dali::PathConstrainer *result = 0 ;
41020
41021   {
41022     try {
41023       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
41024     } catch (std::out_of_range& e) {
41025       {
41026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41027       };
41028     } catch (std::exception& e) {
41029       {
41030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41031       };
41032     } catch (...) {
41033       {
41034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41035       };
41036     }
41037   }
41038   jresult = (void *)result;
41039   return jresult;
41040 }
41041
41042
41043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
41044   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41045
41046   arg1 = (Dali::PathConstrainer *)jarg1;
41047   {
41048     try {
41049       delete arg1;
41050     } catch (std::out_of_range& e) {
41051       {
41052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41053       };
41054     } catch (std::exception& e) {
41055       {
41056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41057       };
41058     } catch (...) {
41059       {
41060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41061       };
41062     }
41063   }
41064 }
41065
41066
41067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
41068   void * jresult ;
41069   Dali::PathConstrainer *arg1 = 0 ;
41070   Dali::PathConstrainer *result = 0 ;
41071
41072   arg1 = (Dali::PathConstrainer *)jarg1;
41073   if (!arg1) {
41074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
41075     return 0;
41076   }
41077   {
41078     try {
41079       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
41080     } catch (std::out_of_range& e) {
41081       {
41082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41083       };
41084     } catch (std::exception& e) {
41085       {
41086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41087       };
41088     } catch (...) {
41089       {
41090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41091       };
41092     }
41093   }
41094   jresult = (void *)result;
41095   return jresult;
41096 }
41097
41098
41099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
41100   void * jresult ;
41101   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41102   Dali::PathConstrainer *arg2 = 0 ;
41103   Dali::PathConstrainer *result = 0 ;
41104
41105   arg1 = (Dali::PathConstrainer *)jarg1;
41106   arg2 = (Dali::PathConstrainer *)jarg2;
41107   if (!arg2) {
41108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
41109     return 0;
41110   }
41111   {
41112     try {
41113       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
41114     } catch (std::out_of_range& e) {
41115       {
41116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41117       };
41118     } catch (std::exception& e) {
41119       {
41120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41121       };
41122     } catch (...) {
41123       {
41124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41125       };
41126     }
41127   }
41128   jresult = (void *)result;
41129   return jresult;
41130 }
41131
41132
41133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
41134   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41135   SwigValueWrapper< Dali::Property > arg2 ;
41136   SwigValueWrapper< Dali::Property > arg3 ;
41137   Dali::Vector2 *arg4 = 0 ;
41138   Dali::Vector2 *arg5 = 0 ;
41139   Dali::Property *argp2 ;
41140   Dali::Property *argp3 ;
41141
41142   arg1 = (Dali::PathConstrainer *)jarg1;
41143   argp2 = (Dali::Property *)jarg2;
41144   if (!argp2) {
41145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41146     return ;
41147   }
41148   arg2 = *argp2;
41149   argp3 = (Dali::Property *)jarg3;
41150   if (!argp3) {
41151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41152     return ;
41153   }
41154   arg3 = *argp3;
41155   arg4 = (Dali::Vector2 *)jarg4;
41156   if (!arg4) {
41157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41158     return ;
41159   }
41160   arg5 = (Dali::Vector2 *)jarg5;
41161   if (!arg5) {
41162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41163     return ;
41164   }
41165   {
41166     try {
41167       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
41168     } catch (std::out_of_range& e) {
41169       {
41170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41171       };
41172     } catch (std::exception& e) {
41173       {
41174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41175       };
41176     } catch (...) {
41177       {
41178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41179       };
41180     }
41181   }
41182 }
41183
41184
41185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
41186   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41187   SwigValueWrapper< Dali::Property > arg2 ;
41188   SwigValueWrapper< Dali::Property > arg3 ;
41189   Dali::Vector2 *arg4 = 0 ;
41190   Dali::Property *argp2 ;
41191   Dali::Property *argp3 ;
41192
41193   arg1 = (Dali::PathConstrainer *)jarg1;
41194   argp2 = (Dali::Property *)jarg2;
41195   if (!argp2) {
41196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41197     return ;
41198   }
41199   arg2 = *argp2;
41200   argp3 = (Dali::Property *)jarg3;
41201   if (!argp3) {
41202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41203     return ;
41204   }
41205   arg3 = *argp3;
41206   arg4 = (Dali::Vector2 *)jarg4;
41207   if (!arg4) {
41208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41209     return ;
41210   }
41211   {
41212     try {
41213       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
41214     } catch (std::out_of_range& e) {
41215       {
41216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41217       };
41218     } catch (std::exception& e) {
41219       {
41220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41221       };
41222     } catch (...) {
41223       {
41224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41225       };
41226     }
41227   }
41228 }
41229
41230
41231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
41232   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41233   Dali::Handle *arg2 = 0 ;
41234
41235   arg1 = (Dali::PathConstrainer *)jarg1;
41236   arg2 = (Dali::Handle *)jarg2;
41237   if (!arg2) {
41238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
41239     return ;
41240   }
41241   {
41242     try {
41243       (arg1)->Remove(*arg2);
41244     } catch (std::out_of_range& e) {
41245       {
41246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41247       };
41248     } catch (std::exception& e) {
41249       {
41250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41251       };
41252     } catch (...) {
41253       {
41254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41255       };
41256     }
41257   }
41258 }
41259
41260
41261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
41262   int jresult ;
41263   Dali::FittingMode::Type result;
41264
41265   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
41266   jresult = (int)result;
41267   return jresult;
41268 }
41269
41270
41271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
41272   int jresult ;
41273   Dali::SamplingMode::Type result;
41274
41275   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
41276   jresult = (int)result;
41277   return jresult;
41278 }
41279
41280
41281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
41282   void * jresult ;
41283   Dali::BufferImage *result = 0 ;
41284
41285   {
41286     try {
41287       result = (Dali::BufferImage *)new Dali::BufferImage();
41288     } catch (std::out_of_range& e) {
41289       {
41290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41291       };
41292     } catch (std::exception& e) {
41293       {
41294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41295       };
41296     } catch (...) {
41297       {
41298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41299       };
41300     }
41301   }
41302   jresult = (void *)result;
41303   return jresult;
41304 }
41305
41306
41307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
41308   void * jresult ;
41309   unsigned int arg1 ;
41310   unsigned int arg2 ;
41311   Dali::Pixel::Format arg3 ;
41312   Dali::BufferImage result;
41313
41314   arg1 = (unsigned int)jarg1;
41315   arg2 = (unsigned int)jarg2;
41316   arg3 = (Dali::Pixel::Format)jarg3;
41317   {
41318     try {
41319       result = Dali::BufferImage::New(arg1,arg2,arg3);
41320     } catch (std::out_of_range& e) {
41321       {
41322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41323       };
41324     } catch (std::exception& e) {
41325       {
41326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41327       };
41328     } catch (...) {
41329       {
41330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41331       };
41332     }
41333   }
41334   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41335   return jresult;
41336 }
41337
41338
41339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
41340   void * jresult ;
41341   unsigned int arg1 ;
41342   unsigned int arg2 ;
41343   Dali::BufferImage result;
41344
41345   arg1 = (unsigned int)jarg1;
41346   arg2 = (unsigned int)jarg2;
41347   {
41348     try {
41349       result = Dali::BufferImage::New(arg1,arg2);
41350     } catch (std::out_of_range& e) {
41351       {
41352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41353       };
41354     } catch (std::exception& e) {
41355       {
41356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41357       };
41358     } catch (...) {
41359       {
41360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41361       };
41362     }
41363   }
41364   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41365   return jresult;
41366 }
41367
41368
41369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
41370   void * jresult ;
41371   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41372   unsigned int arg2 ;
41373   unsigned int arg3 ;
41374   Dali::Pixel::Format arg4 ;
41375   unsigned int arg5 ;
41376   Dali::BufferImage result;
41377
41378   arg1 = jarg1;
41379   arg2 = (unsigned int)jarg2;
41380   arg3 = (unsigned int)jarg3;
41381   arg4 = (Dali::Pixel::Format)jarg4;
41382   arg5 = (unsigned int)jarg5;
41383   {
41384     try {
41385       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
41386     } catch (std::out_of_range& e) {
41387       {
41388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41389       };
41390     } catch (std::exception& e) {
41391       {
41392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41393       };
41394     } catch (...) {
41395       {
41396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41397       };
41398     }
41399   }
41400   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41401
41402
41403   return jresult;
41404 }
41405
41406
41407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
41408   void * jresult ;
41409   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41410   unsigned int arg2 ;
41411   unsigned int arg3 ;
41412   Dali::Pixel::Format arg4 ;
41413   Dali::BufferImage result;
41414
41415   arg1 = jarg1;
41416   arg2 = (unsigned int)jarg2;
41417   arg3 = (unsigned int)jarg3;
41418   arg4 = (Dali::Pixel::Format)jarg4;
41419   {
41420     try {
41421       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
41422     } catch (std::out_of_range& e) {
41423       {
41424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41425       };
41426     } catch (std::exception& e) {
41427       {
41428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41429       };
41430     } catch (...) {
41431       {
41432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41433       };
41434     }
41435   }
41436   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41437
41438
41439   return jresult;
41440 }
41441
41442
41443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
41444   void * jresult ;
41445   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41446   unsigned int arg2 ;
41447   unsigned int arg3 ;
41448   Dali::BufferImage result;
41449
41450   arg1 = jarg1;
41451   arg2 = (unsigned int)jarg2;
41452   arg3 = (unsigned int)jarg3;
41453   {
41454     try {
41455       result = Dali::BufferImage::New(arg1,arg2,arg3);
41456     } catch (std::out_of_range& e) {
41457       {
41458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41459       };
41460     } catch (std::exception& e) {
41461       {
41462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41463       };
41464     } catch (...) {
41465       {
41466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41467       };
41468     }
41469   }
41470   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41471
41472
41473   return jresult;
41474 }
41475
41476
41477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
41478   void * jresult ;
41479   Dali::BaseHandle arg1 ;
41480   Dali::BaseHandle *argp1 ;
41481   Dali::BufferImage result;
41482
41483   argp1 = (Dali::BaseHandle *)jarg1;
41484   if (!argp1) {
41485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41486     return 0;
41487   }
41488   arg1 = *argp1;
41489   {
41490     try {
41491       result = Dali::BufferImage::DownCast(arg1);
41492     } catch (std::out_of_range& e) {
41493       {
41494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41495       };
41496     } catch (std::exception& e) {
41497       {
41498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41499       };
41500     } catch (...) {
41501       {
41502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41503       };
41504     }
41505   }
41506   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41507   return jresult;
41508 }
41509
41510
41511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
41512   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41513
41514   arg1 = (Dali::BufferImage *)jarg1;
41515   {
41516     try {
41517       delete arg1;
41518     } catch (std::out_of_range& e) {
41519       {
41520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41521       };
41522     } catch (std::exception& e) {
41523       {
41524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41525       };
41526     } catch (...) {
41527       {
41528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41529       };
41530     }
41531   }
41532 }
41533
41534
41535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
41536   void * jresult ;
41537   Dali::BufferImage *arg1 = 0 ;
41538   Dali::BufferImage *result = 0 ;
41539
41540   arg1 = (Dali::BufferImage *)jarg1;
41541   if (!arg1) {
41542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41543     return 0;
41544   }
41545   {
41546     try {
41547       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
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 = (void *)result;
41563   return jresult;
41564 }
41565
41566
41567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
41568   void * jresult ;
41569   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41570   Dali::BufferImage *arg2 = 0 ;
41571   Dali::BufferImage *result = 0 ;
41572
41573   arg1 = (Dali::BufferImage *)jarg1;
41574   arg2 = (Dali::BufferImage *)jarg2;
41575   if (!arg2) {
41576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41577     return 0;
41578   }
41579   {
41580     try {
41581       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
41582     } catch (std::out_of_range& e) {
41583       {
41584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41585       };
41586     } catch (std::exception& e) {
41587       {
41588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41589       };
41590     } catch (...) {
41591       {
41592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41593       };
41594     }
41595   }
41596   jresult = (void *)result;
41597   return jresult;
41598 }
41599
41600
41601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
41602   void * jresult ;
41603   Dali::BufferImage result;
41604
41605   {
41606     try {
41607       result = Dali::BufferImage::WHITE();
41608     } catch (std::out_of_range& e) {
41609       {
41610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41611       };
41612     } catch (std::exception& e) {
41613       {
41614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41615       };
41616     } catch (...) {
41617       {
41618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41619       };
41620     }
41621   }
41622   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41623   return jresult;
41624 }
41625
41626
41627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
41628   void * jresult ;
41629   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41630   Dali::PixelBuffer *result = 0 ;
41631
41632   arg1 = (Dali::BufferImage *)jarg1;
41633   {
41634     try {
41635       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
41636     } catch (std::out_of_range& e) {
41637       {
41638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41639       };
41640     } catch (std::exception& e) {
41641       {
41642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41643       };
41644     } catch (...) {
41645       {
41646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41647       };
41648     }
41649   }
41650   jresult = (void *)result;
41651   return jresult;
41652 }
41653
41654
41655 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
41656   unsigned int jresult ;
41657   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41658   unsigned int result;
41659
41660   arg1 = (Dali::BufferImage *)jarg1;
41661   {
41662     try {
41663       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
41664     } catch (std::out_of_range& e) {
41665       {
41666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41667       };
41668     } catch (std::exception& e) {
41669       {
41670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41671       };
41672     } catch (...) {
41673       {
41674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41675       };
41676     }
41677   }
41678   jresult = result;
41679   return jresult;
41680 }
41681
41682
41683 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
41684   unsigned int jresult ;
41685   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41686   unsigned int result;
41687
41688   arg1 = (Dali::BufferImage *)jarg1;
41689   {
41690     try {
41691       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
41692     } catch (std::out_of_range& e) {
41693       {
41694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41695       };
41696     } catch (std::exception& e) {
41697       {
41698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41699       };
41700     } catch (...) {
41701       {
41702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41703       };
41704     }
41705   }
41706   jresult = result;
41707   return jresult;
41708 }
41709
41710
41711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
41712   int jresult ;
41713   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41714   Dali::Pixel::Format result;
41715
41716   arg1 = (Dali::BufferImage *)jarg1;
41717   {
41718     try {
41719       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
41720     } catch (std::out_of_range& e) {
41721       {
41722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41723       };
41724     } catch (std::exception& e) {
41725       {
41726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41727       };
41728     } catch (...) {
41729       {
41730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41731       };
41732     }
41733   }
41734   jresult = (int)result;
41735   return jresult;
41736 }
41737
41738
41739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
41740   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41741
41742   arg1 = (Dali::BufferImage *)jarg1;
41743   {
41744     try {
41745       (arg1)->Update();
41746     } catch (std::out_of_range& e) {
41747       {
41748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41749       };
41750     } catch (std::exception& e) {
41751       {
41752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41753       };
41754     } catch (...) {
41755       {
41756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41757       };
41758     }
41759   }
41760 }
41761
41762
41763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
41764   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41765   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
41766   Dali::RectArea *argp2 ;
41767
41768   arg1 = (Dali::BufferImage *)jarg1;
41769   argp2 = (Dali::RectArea *)jarg2;
41770   if (!argp2) {
41771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
41772     return ;
41773   }
41774   arg2 = *argp2;
41775   {
41776     try {
41777       (arg1)->Update(arg2);
41778     } catch (std::out_of_range& e) {
41779       {
41780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41781       };
41782     } catch (std::exception& e) {
41783       {
41784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41785       };
41786     } catch (...) {
41787       {
41788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41789       };
41790     }
41791   }
41792 }
41793
41794
41795 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
41796   unsigned int jresult ;
41797   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41798   bool result;
41799
41800   arg1 = (Dali::BufferImage *)jarg1;
41801   {
41802     try {
41803       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
41804     } catch (std::out_of_range& e) {
41805       {
41806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41807       };
41808     } catch (std::exception& e) {
41809       {
41810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41811       };
41812     } catch (...) {
41813       {
41814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41815       };
41816     }
41817   }
41818   jresult = result;
41819   return jresult;
41820 }
41821
41822
41823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
41824   void * jresult ;
41825   Dali::EncodedBufferImage *result = 0 ;
41826
41827   {
41828     try {
41829       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
41830     } catch (std::out_of_range& e) {
41831       {
41832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41833       };
41834     } catch (std::exception& e) {
41835       {
41836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41837       };
41838     } catch (...) {
41839       {
41840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41841       };
41842     }
41843   }
41844   jresult = (void *)result;
41845   return jresult;
41846 }
41847
41848
41849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
41850   void * jresult ;
41851   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41852   std::size_t arg2 ;
41853   Dali::EncodedBufferImage result;
41854
41855   arg1 = (uint8_t *)jarg1;
41856   arg2 = (std::size_t)jarg2;
41857   {
41858     try {
41859       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
41860     } catch (std::out_of_range& e) {
41861       {
41862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41863       };
41864     } catch (std::exception& e) {
41865       {
41866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41867       };
41868     } catch (...) {
41869       {
41870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41871       };
41872     }
41873   }
41874   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41875   return jresult;
41876 }
41877
41878
41879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
41880   void * jresult ;
41881   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41882   std::size_t arg2 ;
41883   Dali::ImageDimensions arg3 ;
41884   Dali::FittingMode::Type arg4 ;
41885   Dali::SamplingMode::Type arg5 ;
41886   bool arg6 ;
41887   Dali::ImageDimensions *argp3 ;
41888   Dali::EncodedBufferImage result;
41889
41890   arg1 = (uint8_t *)jarg1;
41891   arg2 = (std::size_t)jarg2;
41892   argp3 = (Dali::ImageDimensions *)jarg3;
41893   if (!argp3) {
41894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41895     return 0;
41896   }
41897   arg3 = *argp3;
41898   arg4 = (Dali::FittingMode::Type)jarg4;
41899   arg5 = (Dali::SamplingMode::Type)jarg5;
41900   arg6 = jarg6 ? true : false;
41901   {
41902     try {
41903       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
41904     } catch (std::out_of_range& e) {
41905       {
41906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41907       };
41908     } catch (std::exception& e) {
41909       {
41910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41911       };
41912     } catch (...) {
41913       {
41914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41915       };
41916     }
41917   }
41918   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41919   return jresult;
41920 }
41921
41922
41923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
41924   void * jresult ;
41925   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41926   std::size_t arg2 ;
41927   Dali::ImageDimensions arg3 ;
41928   Dali::FittingMode::Type arg4 ;
41929   Dali::SamplingMode::Type arg5 ;
41930   Dali::ImageDimensions *argp3 ;
41931   Dali::EncodedBufferImage result;
41932
41933   arg1 = (uint8_t *)jarg1;
41934   arg2 = (std::size_t)jarg2;
41935   argp3 = (Dali::ImageDimensions *)jarg3;
41936   if (!argp3) {
41937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41938     return 0;
41939   }
41940   arg3 = *argp3;
41941   arg4 = (Dali::FittingMode::Type)jarg4;
41942   arg5 = (Dali::SamplingMode::Type)jarg5;
41943   {
41944     try {
41945       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
41946     } catch (std::out_of_range& e) {
41947       {
41948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41949       };
41950     } catch (std::exception& e) {
41951       {
41952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41953       };
41954     } catch (...) {
41955       {
41956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41957       };
41958     }
41959   }
41960   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41961   return jresult;
41962 }
41963
41964
41965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
41966   void * jresult ;
41967   Dali::BaseHandle arg1 ;
41968   Dali::BaseHandle *argp1 ;
41969   Dali::EncodedBufferImage result;
41970
41971   argp1 = (Dali::BaseHandle *)jarg1;
41972   if (!argp1) {
41973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41974     return 0;
41975   }
41976   arg1 = *argp1;
41977   {
41978     try {
41979       result = Dali::EncodedBufferImage::DownCast(arg1);
41980     } catch (std::out_of_range& e) {
41981       {
41982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41983       };
41984     } catch (std::exception& e) {
41985       {
41986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41987       };
41988     } catch (...) {
41989       {
41990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41991       };
41992     }
41993   }
41994   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41995   return jresult;
41996 }
41997
41998
41999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
42000   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
42001
42002   arg1 = (Dali::EncodedBufferImage *)jarg1;
42003   {
42004     try {
42005       delete arg1;
42006     } catch (std::out_of_range& e) {
42007       {
42008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42009       };
42010     } catch (std::exception& e) {
42011       {
42012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42013       };
42014     } catch (...) {
42015       {
42016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42017       };
42018     }
42019   }
42020 }
42021
42022
42023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
42024   void * jresult ;
42025   Dali::EncodedBufferImage *arg1 = 0 ;
42026   Dali::EncodedBufferImage *result = 0 ;
42027
42028   arg1 = (Dali::EncodedBufferImage *)jarg1;
42029   if (!arg1) {
42030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
42031     return 0;
42032   }
42033   {
42034     try {
42035       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
42036     } catch (std::out_of_range& e) {
42037       {
42038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42039       };
42040     } catch (std::exception& e) {
42041       {
42042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42043       };
42044     } catch (...) {
42045       {
42046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42047       };
42048     }
42049   }
42050   jresult = (void *)result;
42051   return jresult;
42052 }
42053
42054
42055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
42056   void * jresult ;
42057   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
42058   Dali::EncodedBufferImage *arg2 = 0 ;
42059   Dali::EncodedBufferImage *result = 0 ;
42060
42061   arg1 = (Dali::EncodedBufferImage *)jarg1;
42062   arg2 = (Dali::EncodedBufferImage *)jarg2;
42063   if (!arg2) {
42064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
42065     return 0;
42066   }
42067   {
42068     try {
42069       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
42070     } catch (std::out_of_range& e) {
42071       {
42072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42073       };
42074     } catch (std::exception& e) {
42075       {
42076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42077       };
42078     } catch (...) {
42079       {
42080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42081       };
42082     }
42083   }
42084   jresult = (void *)result;
42085   return jresult;
42086 }
42087
42088
42089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
42090   void * jresult ;
42091   Dali::NativeImage *result = 0 ;
42092
42093   {
42094     try {
42095       result = (Dali::NativeImage *)new Dali::NativeImage();
42096     } catch (std::out_of_range& e) {
42097       {
42098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42099       };
42100     } catch (std::exception& e) {
42101       {
42102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42103       };
42104     } catch (...) {
42105       {
42106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42107       };
42108     }
42109   }
42110   jresult = (void *)result;
42111   return jresult;
42112 }
42113
42114
42115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
42116   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42117
42118   arg1 = (Dali::NativeImage *)jarg1;
42119   {
42120     try {
42121       delete arg1;
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 void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
42140   void * jresult ;
42141   Dali::NativeImage *arg1 = 0 ;
42142   Dali::NativeImage *result = 0 ;
42143
42144   arg1 = (Dali::NativeImage *)jarg1;
42145   if (!arg1) {
42146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
42147     return 0;
42148   }
42149   {
42150     try {
42151       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
42152     } catch (std::out_of_range& e) {
42153       {
42154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42155       };
42156     } catch (std::exception& e) {
42157       {
42158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42159       };
42160     } catch (...) {
42161       {
42162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42163       };
42164     }
42165   }
42166   jresult = (void *)result;
42167   return jresult;
42168 }
42169
42170
42171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
42172   void * jresult ;
42173   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42174   Dali::NativeImage *arg2 = 0 ;
42175   Dali::NativeImage *result = 0 ;
42176
42177   arg1 = (Dali::NativeImage *)jarg1;
42178   arg2 = (Dali::NativeImage *)jarg2;
42179   if (!arg2) {
42180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
42181     return 0;
42182   }
42183   {
42184     try {
42185       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
42186     } catch (std::out_of_range& e) {
42187       {
42188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42189       };
42190     } catch (std::exception& e) {
42191       {
42192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42193       };
42194     } catch (...) {
42195       {
42196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42197       };
42198     }
42199   }
42200   jresult = (void *)result;
42201   return jresult;
42202 }
42203
42204
42205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
42206   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42207
42208   arg1 = (Dali::NativeImage *)jarg1;
42209   {
42210     try {
42211       (arg1)->CreateGlTexture();
42212     } catch (std::out_of_range& e) {
42213       {
42214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42215       };
42216     } catch (std::exception& e) {
42217       {
42218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42219       };
42220     } catch (...) {
42221       {
42222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42223       };
42224     }
42225   }
42226 }
42227
42228
42229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
42230   void * jresult ;
42231   NativeImageInterface *arg1 = 0 ;
42232   Dali::NativeImage result;
42233
42234   arg1 = (NativeImageInterface *)jarg1;
42235   if (!arg1) {
42236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
42237     return 0;
42238   }
42239   {
42240     try {
42241       result = Dali::NativeImage::New(*arg1);
42242     } catch (std::out_of_range& e) {
42243       {
42244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42245       };
42246     } catch (std::exception& e) {
42247       {
42248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42249       };
42250     } catch (...) {
42251       {
42252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42253       };
42254     }
42255   }
42256   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
42257   return jresult;
42258 }
42259
42260
42261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
42262   void * jresult ;
42263   Dali::BaseHandle arg1 ;
42264   Dali::BaseHandle *argp1 ;
42265   Dali::NativeImage result;
42266
42267   argp1 = (Dali::BaseHandle *)jarg1;
42268   if (!argp1) {
42269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42270     return 0;
42271   }
42272   arg1 = *argp1;
42273   {
42274     try {
42275       result = Dali::NativeImage::DownCast(arg1);
42276     } catch (std::out_of_range& e) {
42277       {
42278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42279       };
42280     } catch (std::exception& e) {
42281       {
42282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42283       };
42284     } catch (...) {
42285       {
42286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42287       };
42288     }
42289   }
42290   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
42291   return jresult;
42292 }
42293
42294
42295 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
42296   char * jresult ;
42297   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42298   char *result = 0 ;
42299
42300   arg1 = (Dali::NativeImage *)jarg1;
42301   {
42302     try {
42303       result = (char *)(arg1)->GetCustomFragmentPreFix();
42304     } catch (std::out_of_range& e) {
42305       {
42306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42307       };
42308     } catch (std::exception& e) {
42309       {
42310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42311       };
42312     } catch (...) {
42313       {
42314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42315       };
42316     }
42317   }
42318   jresult = SWIG_csharp_string_callback((const char *)result);
42319   return jresult;
42320 }
42321
42322
42323 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
42324   char * jresult ;
42325   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42326   char *result = 0 ;
42327
42328   arg1 = (Dali::NativeImage *)jarg1;
42329   {
42330     try {
42331       result = (char *)(arg1)->GetCustomSamplerTypename();
42332     } catch (std::out_of_range& e) {
42333       {
42334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42335       };
42336     } catch (std::exception& e) {
42337       {
42338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42339       };
42340     } catch (...) {
42341       {
42342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42343       };
42344     }
42345   }
42346   jresult = SWIG_csharp_string_callback((const char *)result);
42347   return jresult;
42348 }
42349
42350
42351 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
42352   unsigned int jresult ;
42353   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42354   bool result;
42355
42356   arg1 = (Dali::NativeImageInterface *)jarg1;
42357   {
42358     try {
42359       result = (bool)(arg1)->GlExtensionCreate();
42360     } catch (std::out_of_range& e) {
42361       {
42362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42363       };
42364     } catch (std::exception& e) {
42365       {
42366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42367       };
42368     } catch (...) {
42369       {
42370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42371       };
42372     }
42373   }
42374   jresult = result;
42375   return jresult;
42376 }
42377
42378
42379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
42380   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42381
42382   arg1 = (Dali::NativeImageInterface *)jarg1;
42383   {
42384     try {
42385       (arg1)->GlExtensionDestroy();
42386     } catch (std::out_of_range& e) {
42387       {
42388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42389       };
42390     } catch (std::exception& e) {
42391       {
42392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42393       };
42394     } catch (...) {
42395       {
42396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42397       };
42398     }
42399   }
42400 }
42401
42402
42403 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
42404   unsigned int jresult ;
42405   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42406   unsigned int result;
42407
42408   arg1 = (Dali::NativeImageInterface *)jarg1;
42409   {
42410     try {
42411       result = (unsigned int)(arg1)->TargetTexture();
42412     } catch (std::out_of_range& e) {
42413       {
42414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42415       };
42416     } catch (std::exception& e) {
42417       {
42418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42419       };
42420     } catch (...) {
42421       {
42422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42423       };
42424     }
42425   }
42426   jresult = result;
42427   return jresult;
42428 }
42429
42430
42431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
42432   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42433
42434   arg1 = (Dali::NativeImageInterface *)jarg1;
42435   {
42436     try {
42437       (arg1)->PrepareTexture();
42438     } catch (std::out_of_range& e) {
42439       {
42440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42441       };
42442     } catch (std::exception& e) {
42443       {
42444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42445       };
42446     } catch (...) {
42447       {
42448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42449       };
42450     }
42451   }
42452 }
42453
42454
42455 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
42456   unsigned int jresult ;
42457   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42458   unsigned int result;
42459
42460   arg1 = (Dali::NativeImageInterface *)jarg1;
42461   {
42462     try {
42463       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
42464     } catch (std::out_of_range& e) {
42465       {
42466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42467       };
42468     } catch (std::exception& e) {
42469       {
42470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42471       };
42472     } catch (...) {
42473       {
42474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42475       };
42476     }
42477   }
42478   jresult = result;
42479   return jresult;
42480 }
42481
42482
42483 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
42484   unsigned int jresult ;
42485   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42486   unsigned int result;
42487
42488   arg1 = (Dali::NativeImageInterface *)jarg1;
42489   {
42490     try {
42491       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
42492     } catch (std::out_of_range& e) {
42493       {
42494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42495       };
42496     } catch (std::exception& e) {
42497       {
42498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42499       };
42500     } catch (...) {
42501       {
42502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42503       };
42504     }
42505   }
42506   jresult = result;
42507   return jresult;
42508 }
42509
42510
42511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
42512   unsigned int jresult ;
42513   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42514   bool result;
42515
42516   arg1 = (Dali::NativeImageInterface *)jarg1;
42517   {
42518     try {
42519       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
42520     } catch (std::out_of_range& e) {
42521       {
42522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42523       };
42524     } catch (std::exception& e) {
42525       {
42526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42527       };
42528     } catch (...) {
42529       {
42530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42531       };
42532     }
42533   }
42534   jresult = result;
42535   return jresult;
42536 }
42537
42538
42539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
42540   void * jresult ;
42541   std::string *arg1 = 0 ;
42542   Dali::ImageDimensions result;
42543
42544   if (!jarg1) {
42545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42546     return 0;
42547   }
42548   std::string arg1_str(jarg1);
42549   arg1 = &arg1_str;
42550   {
42551     try {
42552       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
42553     } catch (std::out_of_range& e) {
42554       {
42555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42556       };
42557     } catch (std::exception& e) {
42558       {
42559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42560       };
42561     } catch (...) {
42562       {
42563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42564       };
42565     }
42566   }
42567   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
42568
42569   //argout typemap for const std::string&
42570
42571   return jresult;
42572 }
42573
42574
42575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
42576   void * jresult ;
42577   Dali::ResourceImage *result = 0 ;
42578
42579   {
42580     try {
42581       result = (Dali::ResourceImage *)new Dali::ResourceImage();
42582     } catch (std::out_of_range& e) {
42583       {
42584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42585       };
42586     } catch (std::exception& e) {
42587       {
42588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42589       };
42590     } catch (...) {
42591       {
42592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42593       };
42594     }
42595   }
42596   jresult = (void *)result;
42597   return jresult;
42598 }
42599
42600
42601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
42602   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42603
42604   arg1 = (Dali::ResourceImage *)jarg1;
42605   {
42606     try {
42607       delete arg1;
42608     } catch (std::out_of_range& e) {
42609       {
42610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42611       };
42612     } catch (std::exception& e) {
42613       {
42614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42615       };
42616     } catch (...) {
42617       {
42618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42619       };
42620     }
42621   }
42622 }
42623
42624
42625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
42626   void * jresult ;
42627   Dali::ResourceImage *arg1 = 0 ;
42628   Dali::ResourceImage *result = 0 ;
42629
42630   arg1 = (Dali::ResourceImage *)jarg1;
42631   if (!arg1) {
42632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42633     return 0;
42634   }
42635   {
42636     try {
42637       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
42638     } catch (std::out_of_range& e) {
42639       {
42640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42641       };
42642     } catch (std::exception& e) {
42643       {
42644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42645       };
42646     } catch (...) {
42647       {
42648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42649       };
42650     }
42651   }
42652   jresult = (void *)result;
42653   return jresult;
42654 }
42655
42656
42657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
42658   void * jresult ;
42659   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42660   Dali::ResourceImage *arg2 = 0 ;
42661   Dali::ResourceImage *result = 0 ;
42662
42663   arg1 = (Dali::ResourceImage *)jarg1;
42664   arg2 = (Dali::ResourceImage *)jarg2;
42665   if (!arg2) {
42666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42667     return 0;
42668   }
42669   {
42670     try {
42671       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
42672     } catch (std::out_of_range& e) {
42673       {
42674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42675       };
42676     } catch (std::exception& e) {
42677       {
42678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42679       };
42680     } catch (...) {
42681       {
42682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42683       };
42684     }
42685   }
42686   jresult = (void *)result;
42687   return jresult;
42688 }
42689
42690
42691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
42692   void * jresult ;
42693   std::string *arg1 = 0 ;
42694   bool arg2 ;
42695   Dali::ResourceImage result;
42696
42697   if (!jarg1) {
42698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42699     return 0;
42700   }
42701   std::string arg1_str(jarg1);
42702   arg1 = &arg1_str;
42703   arg2 = jarg2 ? true : false;
42704   {
42705     try {
42706       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42707     } catch (std::out_of_range& e) {
42708       {
42709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42710       };
42711     } catch (std::exception& e) {
42712       {
42713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42714       };
42715     } catch (...) {
42716       {
42717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42718       };
42719     }
42720   }
42721   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42722
42723   //argout typemap for const std::string&
42724
42725   return jresult;
42726 }
42727
42728
42729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
42730   void * jresult ;
42731   std::string *arg1 = 0 ;
42732   Dali::ResourceImage result;
42733
42734   if (!jarg1) {
42735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42736     return 0;
42737   }
42738   std::string arg1_str(jarg1);
42739   arg1 = &arg1_str;
42740   {
42741     try {
42742       result = Dali::ResourceImage::New((std::string const &)*arg1);
42743     } catch (std::out_of_range& e) {
42744       {
42745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42746       };
42747     } catch (std::exception& e) {
42748       {
42749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42750       };
42751     } catch (...) {
42752       {
42753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42754       };
42755     }
42756   }
42757   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42758
42759   //argout typemap for const std::string&
42760
42761   return jresult;
42762 }
42763
42764
42765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
42766   void * jresult ;
42767   std::string *arg1 = 0 ;
42768   Dali::ImageDimensions arg2 ;
42769   Dali::FittingMode::Type arg3 ;
42770   Dali::SamplingMode::Type arg4 ;
42771   bool arg5 ;
42772   Dali::ImageDimensions *argp2 ;
42773   Dali::ResourceImage result;
42774
42775   if (!jarg1) {
42776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42777     return 0;
42778   }
42779   std::string arg1_str(jarg1);
42780   arg1 = &arg1_str;
42781   argp2 = (Dali::ImageDimensions *)jarg2;
42782   if (!argp2) {
42783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42784     return 0;
42785   }
42786   arg2 = *argp2;
42787   arg3 = (Dali::FittingMode::Type)jarg3;
42788   arg4 = (Dali::SamplingMode::Type)jarg4;
42789   arg5 = jarg5 ? true : false;
42790   {
42791     try {
42792       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
42793     } catch (std::out_of_range& e) {
42794       {
42795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42796       };
42797     } catch (std::exception& e) {
42798       {
42799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42800       };
42801     } catch (...) {
42802       {
42803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42804       };
42805     }
42806   }
42807   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42808
42809   //argout typemap for const std::string&
42810
42811   return jresult;
42812 }
42813
42814
42815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
42816   void * jresult ;
42817   std::string *arg1 = 0 ;
42818   Dali::ImageDimensions arg2 ;
42819   Dali::FittingMode::Type arg3 ;
42820   Dali::SamplingMode::Type arg4 ;
42821   Dali::ImageDimensions *argp2 ;
42822   Dali::ResourceImage result;
42823
42824   if (!jarg1) {
42825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42826     return 0;
42827   }
42828   std::string arg1_str(jarg1);
42829   arg1 = &arg1_str;
42830   argp2 = (Dali::ImageDimensions *)jarg2;
42831   if (!argp2) {
42832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42833     return 0;
42834   }
42835   arg2 = *argp2;
42836   arg3 = (Dali::FittingMode::Type)jarg3;
42837   arg4 = (Dali::SamplingMode::Type)jarg4;
42838   {
42839     try {
42840       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
42841     } catch (std::out_of_range& e) {
42842       {
42843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42844       };
42845     } catch (std::exception& e) {
42846       {
42847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42848       };
42849     } catch (...) {
42850       {
42851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42852       };
42853     }
42854   }
42855   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42856
42857   //argout typemap for const std::string&
42858
42859   return jresult;
42860 }
42861
42862
42863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
42864   void * jresult ;
42865   std::string *arg1 = 0 ;
42866   Dali::ImageDimensions arg2 ;
42867   Dali::FittingMode::Type arg3 ;
42868   Dali::ImageDimensions *argp2 ;
42869   Dali::ResourceImage result;
42870
42871   if (!jarg1) {
42872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42873     return 0;
42874   }
42875   std::string arg1_str(jarg1);
42876   arg1 = &arg1_str;
42877   argp2 = (Dali::ImageDimensions *)jarg2;
42878   if (!argp2) {
42879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42880     return 0;
42881   }
42882   arg2 = *argp2;
42883   arg3 = (Dali::FittingMode::Type)jarg3;
42884   {
42885     try {
42886       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
42887     } catch (std::out_of_range& e) {
42888       {
42889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42890       };
42891     } catch (std::exception& e) {
42892       {
42893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42894       };
42895     } catch (...) {
42896       {
42897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42898       };
42899     }
42900   }
42901   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42902
42903   //argout typemap for const std::string&
42904
42905   return jresult;
42906 }
42907
42908
42909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
42910   void * jresult ;
42911   std::string *arg1 = 0 ;
42912   Dali::ImageDimensions arg2 ;
42913   Dali::ImageDimensions *argp2 ;
42914   Dali::ResourceImage result;
42915
42916   if (!jarg1) {
42917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42918     return 0;
42919   }
42920   std::string arg1_str(jarg1);
42921   arg1 = &arg1_str;
42922   argp2 = (Dali::ImageDimensions *)jarg2;
42923   if (!argp2) {
42924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42925     return 0;
42926   }
42927   arg2 = *argp2;
42928   {
42929     try {
42930       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42931     } catch (std::out_of_range& e) {
42932       {
42933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42934       };
42935     } catch (std::exception& e) {
42936       {
42937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42938       };
42939     } catch (...) {
42940       {
42941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42942       };
42943     }
42944   }
42945   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42946
42947   //argout typemap for const std::string&
42948
42949   return jresult;
42950 }
42951
42952
42953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
42954   void * jresult ;
42955   Dali::BaseHandle arg1 ;
42956   Dali::BaseHandle *argp1 ;
42957   Dali::ResourceImage result;
42958
42959   argp1 = (Dali::BaseHandle *)jarg1;
42960   if (!argp1) {
42961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42962     return 0;
42963   }
42964   arg1 = *argp1;
42965   {
42966     try {
42967       result = Dali::ResourceImage::DownCast(arg1);
42968     } catch (std::out_of_range& e) {
42969       {
42970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42971       };
42972     } catch (std::exception& e) {
42973       {
42974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42975       };
42976     } catch (...) {
42977       {
42978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42979       };
42980     }
42981   }
42982   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42983   return jresult;
42984 }
42985
42986
42987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
42988   int jresult ;
42989   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42990   Dali::LoadingState result;
42991
42992   arg1 = (Dali::ResourceImage *)jarg1;
42993   {
42994     try {
42995       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
42996     } catch (std::out_of_range& e) {
42997       {
42998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42999       };
43000     } catch (std::exception& e) {
43001       {
43002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43003       };
43004     } catch (...) {
43005       {
43006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43007       };
43008     }
43009   }
43010   jresult = (int)result;
43011   return jresult;
43012 }
43013
43014
43015 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
43016   char * jresult ;
43017   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
43018   std::string result;
43019
43020   arg1 = (Dali::ResourceImage *)jarg1;
43021   {
43022     try {
43023       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
43024     } catch (std::out_of_range& e) {
43025       {
43026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43027       };
43028     } catch (std::exception& e) {
43029       {
43030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43031       };
43032     } catch (...) {
43033       {
43034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43035       };
43036     }
43037   }
43038   jresult = SWIG_csharp_string_callback((&result)->c_str());
43039   return jresult;
43040 }
43041
43042
43043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
43044   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
43045
43046   arg1 = (Dali::ResourceImage *)jarg1;
43047   {
43048     try {
43049       (arg1)->Reload();
43050     } catch (std::out_of_range& e) {
43051       {
43052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43053       };
43054     } catch (std::exception& e) {
43055       {
43056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43057       };
43058     } catch (...) {
43059       {
43060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43061       };
43062     }
43063   }
43064 }
43065
43066
43067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
43068   void * jresult ;
43069   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
43070   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
43071
43072   arg1 = (Dali::ResourceImage *)jarg1;
43073   {
43074     try {
43075       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
43076     } catch (std::out_of_range& e) {
43077       {
43078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43079       };
43080     } catch (std::exception& e) {
43081       {
43082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43083       };
43084     } catch (...) {
43085       {
43086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43087       };
43088     }
43089   }
43090   jresult = (void *)result;
43091   return jresult;
43092 }
43093
43094
43095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
43096   void * jresult ;
43097   Dali::FrameBufferImage *result = 0 ;
43098
43099   {
43100     try {
43101       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
43102     } catch (std::out_of_range& e) {
43103       {
43104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43105       };
43106     } catch (std::exception& e) {
43107       {
43108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43109       };
43110     } catch (...) {
43111       {
43112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43113       };
43114     }
43115   }
43116   jresult = (void *)result;
43117   return jresult;
43118 }
43119
43120
43121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
43122   void * jresult ;
43123   unsigned int arg1 ;
43124   unsigned int arg2 ;
43125   Dali::Pixel::Format arg3 ;
43126   Dali::RenderBuffer::Format arg4 ;
43127   Dali::FrameBufferImage result;
43128
43129   arg1 = (unsigned int)jarg1;
43130   arg2 = (unsigned int)jarg2;
43131   arg3 = (Dali::Pixel::Format)jarg3;
43132   arg4 = (Dali::RenderBuffer::Format)jarg4;
43133   {
43134     try {
43135       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
43136     } catch (std::out_of_range& e) {
43137       {
43138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43139       };
43140     } catch (std::exception& e) {
43141       {
43142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43143       };
43144     } catch (...) {
43145       {
43146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43147       };
43148     }
43149   }
43150   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43151   return jresult;
43152 }
43153
43154
43155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
43156   void * jresult ;
43157   unsigned int arg1 ;
43158   unsigned int arg2 ;
43159   Dali::Pixel::Format arg3 ;
43160   Dali::FrameBufferImage result;
43161
43162   arg1 = (unsigned int)jarg1;
43163   arg2 = (unsigned int)jarg2;
43164   arg3 = (Dali::Pixel::Format)jarg3;
43165   {
43166     try {
43167       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
43168     } catch (std::out_of_range& e) {
43169       {
43170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43171       };
43172     } catch (std::exception& e) {
43173       {
43174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43175       };
43176     } catch (...) {
43177       {
43178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43179       };
43180     }
43181   }
43182   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43183   return jresult;
43184 }
43185
43186
43187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
43188   void * jresult ;
43189   unsigned int arg1 ;
43190   unsigned int arg2 ;
43191   Dali::FrameBufferImage result;
43192
43193   arg1 = (unsigned int)jarg1;
43194   arg2 = (unsigned int)jarg2;
43195   {
43196     try {
43197       result = Dali::FrameBufferImage::New(arg1,arg2);
43198     } catch (std::out_of_range& e) {
43199       {
43200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43201       };
43202     } catch (std::exception& e) {
43203       {
43204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43205       };
43206     } catch (...) {
43207       {
43208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43209       };
43210     }
43211   }
43212   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43213   return jresult;
43214 }
43215
43216
43217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
43218   void * jresult ;
43219   unsigned int arg1 ;
43220   Dali::FrameBufferImage result;
43221
43222   arg1 = (unsigned int)jarg1;
43223   {
43224     try {
43225       result = Dali::FrameBufferImage::New(arg1);
43226     } catch (std::out_of_range& e) {
43227       {
43228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43229       };
43230     } catch (std::exception& e) {
43231       {
43232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43233       };
43234     } catch (...) {
43235       {
43236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43237       };
43238     }
43239   }
43240   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43241   return jresult;
43242 }
43243
43244
43245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
43246   void * jresult ;
43247   Dali::FrameBufferImage result;
43248
43249   {
43250     try {
43251       result = Dali::FrameBufferImage::New();
43252     } catch (std::out_of_range& e) {
43253       {
43254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43255       };
43256     } catch (std::exception& e) {
43257       {
43258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43259       };
43260     } catch (...) {
43261       {
43262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43263       };
43264     }
43265   }
43266   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43267   return jresult;
43268 }
43269
43270
43271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
43272   void * jresult ;
43273   Dali::NativeImageInterface *arg1 = 0 ;
43274   Dali::FrameBufferImage result;
43275
43276   arg1 = (Dali::NativeImageInterface *)jarg1;
43277   if (!arg1) {
43278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
43279     return 0;
43280   }
43281   {
43282     try {
43283       result = Dali::FrameBufferImage::New(*arg1);
43284     } catch (std::out_of_range& e) {
43285       {
43286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43287       };
43288     } catch (std::exception& e) {
43289       {
43290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43291       };
43292     } catch (...) {
43293       {
43294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43295       };
43296     }
43297   }
43298   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43299   return jresult;
43300 }
43301
43302
43303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
43304   void * jresult ;
43305   Dali::BaseHandle arg1 ;
43306   Dali::BaseHandle *argp1 ;
43307   Dali::FrameBufferImage result;
43308
43309   argp1 = (Dali::BaseHandle *)jarg1;
43310   if (!argp1) {
43311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43312     return 0;
43313   }
43314   arg1 = *argp1;
43315   {
43316     try {
43317       result = Dali::FrameBufferImage::DownCast(arg1);
43318     } catch (std::out_of_range& e) {
43319       {
43320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43321       };
43322     } catch (std::exception& e) {
43323       {
43324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43325       };
43326     } catch (...) {
43327       {
43328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43329       };
43330     }
43331   }
43332   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43333   return jresult;
43334 }
43335
43336
43337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
43338   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
43339
43340   arg1 = (Dali::FrameBufferImage *)jarg1;
43341   {
43342     try {
43343       delete arg1;
43344     } catch (std::out_of_range& e) {
43345       {
43346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43347       };
43348     } catch (std::exception& e) {
43349       {
43350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43351       };
43352     } catch (...) {
43353       {
43354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43355       };
43356     }
43357   }
43358 }
43359
43360
43361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
43362   void * jresult ;
43363   Dali::FrameBufferImage *arg1 = 0 ;
43364   Dali::FrameBufferImage *result = 0 ;
43365
43366   arg1 = (Dali::FrameBufferImage *)jarg1;
43367   if (!arg1) {
43368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
43369     return 0;
43370   }
43371   {
43372     try {
43373       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
43374     } catch (std::out_of_range& e) {
43375       {
43376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43377       };
43378     } catch (std::exception& e) {
43379       {
43380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43381       };
43382     } catch (...) {
43383       {
43384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43385       };
43386     }
43387   }
43388   jresult = (void *)result;
43389   return jresult;
43390 }
43391
43392
43393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
43394   void * jresult ;
43395   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
43396   Dali::FrameBufferImage *arg2 = 0 ;
43397   Dali::FrameBufferImage *result = 0 ;
43398
43399   arg1 = (Dali::FrameBufferImage *)jarg1;
43400   arg2 = (Dali::FrameBufferImage *)jarg2;
43401   if (!arg2) {
43402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
43403     return 0;
43404   }
43405   {
43406     try {
43407       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
43408     } catch (std::out_of_range& e) {
43409       {
43410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43411       };
43412     } catch (std::exception& e) {
43413       {
43414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43415       };
43416     } catch (...) {
43417       {
43418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43419       };
43420     }
43421   }
43422   jresult = (void *)result;
43423   return jresult;
43424 }
43425
43426
43427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
43428   void * jresult ;
43429   Dali::NinePatchImage *result = 0 ;
43430
43431   {
43432     try {
43433       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
43434     } catch (std::out_of_range& e) {
43435       {
43436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43437       };
43438     } catch (std::exception& e) {
43439       {
43440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43441       };
43442     } catch (...) {
43443       {
43444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43445       };
43446     }
43447   }
43448   jresult = (void *)result;
43449   return jresult;
43450 }
43451
43452
43453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
43454   void * jresult ;
43455   std::string *arg1 = 0 ;
43456   Dali::NinePatchImage result;
43457
43458   if (!jarg1) {
43459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43460     return 0;
43461   }
43462   std::string arg1_str(jarg1);
43463   arg1 = &arg1_str;
43464   {
43465     try {
43466       result = Dali::NinePatchImage::New((std::string const &)*arg1);
43467     } catch (std::out_of_range& e) {
43468       {
43469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43470       };
43471     } catch (std::exception& e) {
43472       {
43473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43474       };
43475     } catch (...) {
43476       {
43477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43478       };
43479     }
43480   }
43481   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43482
43483   //argout typemap for const std::string&
43484
43485   return jresult;
43486 }
43487
43488
43489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
43490   void * jresult ;
43491   Dali::BaseHandle arg1 ;
43492   Dali::BaseHandle *argp1 ;
43493   Dali::NinePatchImage result;
43494
43495   argp1 = (Dali::BaseHandle *)jarg1;
43496   if (!argp1) {
43497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43498     return 0;
43499   }
43500   arg1 = *argp1;
43501   {
43502     try {
43503       result = Dali::NinePatchImage::DownCast(arg1);
43504     } catch (std::out_of_range& e) {
43505       {
43506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43507       };
43508     } catch (std::exception& e) {
43509       {
43510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43511       };
43512     } catch (...) {
43513       {
43514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43515       };
43516     }
43517   }
43518   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43519   return jresult;
43520 }
43521
43522
43523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
43524   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43525
43526   arg1 = (Dali::NinePatchImage *)jarg1;
43527   {
43528     try {
43529       delete arg1;
43530     } catch (std::out_of_range& e) {
43531       {
43532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43533       };
43534     } catch (std::exception& e) {
43535       {
43536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43537       };
43538     } catch (...) {
43539       {
43540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43541       };
43542     }
43543   }
43544 }
43545
43546
43547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
43548   void * jresult ;
43549   Dali::NinePatchImage *arg1 = 0 ;
43550   Dali::NinePatchImage *result = 0 ;
43551
43552   arg1 = (Dali::NinePatchImage *)jarg1;
43553   if (!arg1) {
43554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43555     return 0;
43556   }
43557   {
43558     try {
43559       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
43560     } catch (std::out_of_range& e) {
43561       {
43562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43563       };
43564     } catch (std::exception& e) {
43565       {
43566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43567       };
43568     } catch (...) {
43569       {
43570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43571       };
43572     }
43573   }
43574   jresult = (void *)result;
43575   return jresult;
43576 }
43577
43578
43579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
43580   void * jresult ;
43581   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43582   Dali::NinePatchImage *arg2 = 0 ;
43583   Dali::NinePatchImage *result = 0 ;
43584
43585   arg1 = (Dali::NinePatchImage *)jarg1;
43586   arg2 = (Dali::NinePatchImage *)jarg2;
43587   if (!arg2) {
43588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43589     return 0;
43590   }
43591   {
43592     try {
43593       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
43594     } catch (std::out_of_range& e) {
43595       {
43596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43597       };
43598     } catch (std::exception& e) {
43599       {
43600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43601       };
43602     } catch (...) {
43603       {
43604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43605       };
43606     }
43607   }
43608   jresult = (void *)result;
43609   return jresult;
43610 }
43611
43612
43613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
43614   void * jresult ;
43615   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43616   Dali::Vector4 result;
43617
43618   arg1 = (Dali::NinePatchImage *)jarg1;
43619   {
43620     try {
43621       result = (arg1)->GetStretchBorders();
43622     } catch (std::out_of_range& e) {
43623       {
43624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43625       };
43626     } catch (std::exception& e) {
43627       {
43628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43629       };
43630     } catch (...) {
43631       {
43632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43633       };
43634     }
43635   }
43636   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43637   return jresult;
43638 }
43639
43640
43641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
43642   void * jresult ;
43643   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43644   Dali::NinePatchImage::StretchRanges *result = 0 ;
43645
43646   arg1 = (Dali::NinePatchImage *)jarg1;
43647   {
43648     try {
43649       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
43650     } catch (std::out_of_range& e) {
43651       {
43652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43653       };
43654     } catch (std::exception& e) {
43655       {
43656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43657       };
43658     } catch (...) {
43659       {
43660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43661       };
43662     }
43663   }
43664   jresult = (void *)result;
43665   return jresult;
43666 }
43667
43668
43669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
43670   void * jresult ;
43671   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43672   Dali::NinePatchImage::StretchRanges *result = 0 ;
43673
43674   arg1 = (Dali::NinePatchImage *)jarg1;
43675   {
43676     try {
43677       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
43678     } catch (std::out_of_range& e) {
43679       {
43680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43681       };
43682     } catch (std::exception& e) {
43683       {
43684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43685       };
43686     } catch (...) {
43687       {
43688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43689       };
43690     }
43691   }
43692   jresult = (void *)result;
43693   return jresult;
43694 }
43695
43696
43697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
43698   void * jresult ;
43699   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43700   Dali::Rect< int > result;
43701
43702   arg1 = (Dali::NinePatchImage *)jarg1;
43703   {
43704     try {
43705       result = (arg1)->GetChildRectangle();
43706     } catch (std::out_of_range& e) {
43707       {
43708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43709       };
43710     } catch (std::exception& e) {
43711       {
43712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43713       };
43714     } catch (...) {
43715       {
43716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43717       };
43718     }
43719   }
43720   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
43721   return jresult;
43722 }
43723
43724
43725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
43726   void * jresult ;
43727   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43728   Dali::BufferImage result;
43729
43730   arg1 = (Dali::NinePatchImage *)jarg1;
43731   {
43732     try {
43733       result = (arg1)->CreateCroppedBufferImage();
43734     } catch (std::out_of_range& e) {
43735       {
43736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43737       };
43738     } catch (std::exception& e) {
43739       {
43740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43741       };
43742     } catch (...) {
43743       {
43744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43745       };
43746     }
43747   }
43748   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
43749   return jresult;
43750 }
43751
43752
43753 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
43754   unsigned int jresult ;
43755   std::string *arg1 = 0 ;
43756   bool result;
43757
43758   if (!jarg1) {
43759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43760     return 0;
43761   }
43762   std::string arg1_str(jarg1);
43763   arg1 = &arg1_str;
43764   {
43765     try {
43766       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
43767     } catch (std::out_of_range& e) {
43768       {
43769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43770       };
43771     } catch (std::exception& e) {
43772       {
43773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43774       };
43775     } catch (...) {
43776       {
43777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43778       };
43779     }
43780   }
43781   jresult = result;
43782
43783   //argout typemap for const std::string&
43784
43785   return jresult;
43786 }
43787
43788
43789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
43790   int jresult ;
43791   int result;
43792
43793   result = (int)Dali::CameraActor::Property::TYPE;
43794   jresult = (int)result;
43795   return jresult;
43796 }
43797
43798
43799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
43800   int jresult ;
43801   int result;
43802
43803   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
43804   jresult = (int)result;
43805   return jresult;
43806 }
43807
43808
43809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
43810   int jresult ;
43811   int result;
43812
43813   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
43814   jresult = (int)result;
43815   return jresult;
43816 }
43817
43818
43819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
43820   int jresult ;
43821   int result;
43822
43823   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
43824   jresult = (int)result;
43825   return jresult;
43826 }
43827
43828
43829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
43830   int jresult ;
43831   int result;
43832
43833   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
43834   jresult = (int)result;
43835   return jresult;
43836 }
43837
43838
43839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
43840   int jresult ;
43841   int result;
43842
43843   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
43844   jresult = (int)result;
43845   return jresult;
43846 }
43847
43848
43849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
43850   int jresult ;
43851   int result;
43852
43853   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
43854   jresult = (int)result;
43855   return jresult;
43856 }
43857
43858
43859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
43860   int jresult ;
43861   int result;
43862
43863   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
43864   jresult = (int)result;
43865   return jresult;
43866 }
43867
43868
43869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
43870   int jresult ;
43871   int result;
43872
43873   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
43874   jresult = (int)result;
43875   return jresult;
43876 }
43877
43878
43879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
43880   int jresult ;
43881   int result;
43882
43883   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
43884   jresult = (int)result;
43885   return jresult;
43886 }
43887
43888
43889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
43890   int jresult ;
43891   int result;
43892
43893   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
43894   jresult = (int)result;
43895   return jresult;
43896 }
43897
43898
43899 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
43900   int jresult ;
43901   int result;
43902
43903   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
43904   jresult = (int)result;
43905   return jresult;
43906 }
43907
43908
43909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
43910   int jresult ;
43911   int result;
43912
43913   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
43914   jresult = (int)result;
43915   return jresult;
43916 }
43917
43918
43919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
43920   int jresult ;
43921   int result;
43922
43923   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
43924   jresult = (int)result;
43925   return jresult;
43926 }
43927
43928
43929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
43930   void * jresult ;
43931   Dali::CameraActor::Property *result = 0 ;
43932
43933   {
43934     try {
43935       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
43936     } catch (std::out_of_range& e) {
43937       {
43938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43939       };
43940     } catch (std::exception& e) {
43941       {
43942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43943       };
43944     } catch (...) {
43945       {
43946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43947       };
43948     }
43949   }
43950   jresult = (void *)result;
43951   return jresult;
43952 }
43953
43954
43955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
43956   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
43957
43958   arg1 = (Dali::CameraActor::Property *)jarg1;
43959   {
43960     try {
43961       delete arg1;
43962     } catch (std::out_of_range& e) {
43963       {
43964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43965       };
43966     } catch (std::exception& e) {
43967       {
43968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43969       };
43970     } catch (...) {
43971       {
43972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43973       };
43974     }
43975   }
43976 }
43977
43978
43979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
43980   void * jresult ;
43981   Dali::CameraActor *result = 0 ;
43982
43983   {
43984     try {
43985       result = (Dali::CameraActor *)new Dali::CameraActor();
43986     } catch (std::out_of_range& e) {
43987       {
43988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43989       };
43990     } catch (std::exception& e) {
43991       {
43992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43993       };
43994     } catch (...) {
43995       {
43996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43997       };
43998     }
43999   }
44000   jresult = (void *)result;
44001   return jresult;
44002 }
44003
44004
44005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
44006   void * jresult ;
44007   Dali::CameraActor result;
44008
44009   {
44010     try {
44011       result = Dali::CameraActor::New();
44012     } catch (std::out_of_range& e) {
44013       {
44014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44015       };
44016     } catch (std::exception& e) {
44017       {
44018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44019       };
44020     } catch (...) {
44021       {
44022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44023       };
44024     }
44025   }
44026   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44027   return jresult;
44028 }
44029
44030
44031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
44032   void * jresult ;
44033   Dali::Size *arg1 = 0 ;
44034   Dali::CameraActor result;
44035
44036   arg1 = (Dali::Size *)jarg1;
44037   if (!arg1) {
44038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44039     return 0;
44040   }
44041   {
44042     try {
44043       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
44044     } catch (std::out_of_range& e) {
44045       {
44046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44047       };
44048     } catch (std::exception& e) {
44049       {
44050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44051       };
44052     } catch (...) {
44053       {
44054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44055       };
44056     }
44057   }
44058   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44059   return jresult;
44060 }
44061
44062
44063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
44064   void * jresult ;
44065   Dali::BaseHandle arg1 ;
44066   Dali::BaseHandle *argp1 ;
44067   Dali::CameraActor result;
44068
44069   argp1 = (Dali::BaseHandle *)jarg1;
44070   if (!argp1) {
44071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44072     return 0;
44073   }
44074   arg1 = *argp1;
44075   {
44076     try {
44077       result = Dali::CameraActor::DownCast(arg1);
44078     } catch (std::out_of_range& e) {
44079       {
44080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44081       };
44082     } catch (std::exception& e) {
44083       {
44084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44085       };
44086     } catch (...) {
44087       {
44088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44089       };
44090     }
44091   }
44092   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44093   return jresult;
44094 }
44095
44096
44097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
44098   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44099
44100   arg1 = (Dali::CameraActor *)jarg1;
44101   {
44102     try {
44103       delete arg1;
44104     } catch (std::out_of_range& e) {
44105       {
44106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44107       };
44108     } catch (std::exception& e) {
44109       {
44110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44111       };
44112     } catch (...) {
44113       {
44114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44115       };
44116     }
44117   }
44118 }
44119
44120
44121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
44122   void * jresult ;
44123   Dali::CameraActor *arg1 = 0 ;
44124   Dali::CameraActor *result = 0 ;
44125
44126   arg1 = (Dali::CameraActor *)jarg1;
44127   if (!arg1) {
44128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
44129     return 0;
44130   }
44131   {
44132     try {
44133       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
44134     } catch (std::out_of_range& e) {
44135       {
44136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44137       };
44138     } catch (std::exception& e) {
44139       {
44140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44141       };
44142     } catch (...) {
44143       {
44144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44145       };
44146     }
44147   }
44148   jresult = (void *)result;
44149   return jresult;
44150 }
44151
44152
44153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
44154   void * jresult ;
44155   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44156   Dali::CameraActor *arg2 = 0 ;
44157   Dali::CameraActor *result = 0 ;
44158
44159   arg1 = (Dali::CameraActor *)jarg1;
44160   arg2 = (Dali::CameraActor *)jarg2;
44161   if (!arg2) {
44162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
44163     return 0;
44164   }
44165   {
44166     try {
44167       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
44168     } catch (std::out_of_range& e) {
44169       {
44170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44171       };
44172     } catch (std::exception& e) {
44173       {
44174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44175       };
44176     } catch (...) {
44177       {
44178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44179       };
44180     }
44181   }
44182   jresult = (void *)result;
44183   return jresult;
44184 }
44185
44186
44187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
44188   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44189   Dali::Camera::Type arg2 ;
44190
44191   arg1 = (Dali::CameraActor *)jarg1;
44192   arg2 = (Dali::Camera::Type)jarg2;
44193   {
44194     try {
44195       (arg1)->SetType(arg2);
44196     } catch (std::out_of_range& e) {
44197       {
44198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44199       };
44200     } catch (std::exception& e) {
44201       {
44202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44203       };
44204     } catch (...) {
44205       {
44206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44207       };
44208     }
44209   }
44210 }
44211
44212
44213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
44214   int jresult ;
44215   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44216   Dali::Camera::Type result;
44217
44218   arg1 = (Dali::CameraActor *)jarg1;
44219   {
44220     try {
44221       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
44222     } catch (std::out_of_range& e) {
44223       {
44224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44225       };
44226     } catch (std::exception& e) {
44227       {
44228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44229       };
44230     } catch (...) {
44231       {
44232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44233       };
44234     }
44235   }
44236   jresult = (int)result;
44237   return jresult;
44238 }
44239
44240
44241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
44242   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44243   Dali::Camera::ProjectionMode arg2 ;
44244
44245   arg1 = (Dali::CameraActor *)jarg1;
44246   arg2 = (Dali::Camera::ProjectionMode)jarg2;
44247   {
44248     try {
44249       (arg1)->SetProjectionMode(arg2);
44250     } catch (std::out_of_range& e) {
44251       {
44252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44253       };
44254     } catch (std::exception& e) {
44255       {
44256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44257       };
44258     } catch (...) {
44259       {
44260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44261       };
44262     }
44263   }
44264 }
44265
44266
44267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
44268   int jresult ;
44269   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44270   Dali::Camera::ProjectionMode result;
44271
44272   arg1 = (Dali::CameraActor *)jarg1;
44273   {
44274     try {
44275       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
44276     } catch (std::out_of_range& e) {
44277       {
44278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44279       };
44280     } catch (std::exception& e) {
44281       {
44282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44283       };
44284     } catch (...) {
44285       {
44286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44287       };
44288     }
44289   }
44290   jresult = (int)result;
44291   return jresult;
44292 }
44293
44294
44295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
44296   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44297   float arg2 ;
44298
44299   arg1 = (Dali::CameraActor *)jarg1;
44300   arg2 = (float)jarg2;
44301   {
44302     try {
44303       (arg1)->SetFieldOfView(arg2);
44304     } catch (std::out_of_range& e) {
44305       {
44306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44307       };
44308     } catch (std::exception& e) {
44309       {
44310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44311       };
44312     } catch (...) {
44313       {
44314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44315       };
44316     }
44317   }
44318 }
44319
44320
44321 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
44322   float jresult ;
44323   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44324   float result;
44325
44326   arg1 = (Dali::CameraActor *)jarg1;
44327   {
44328     try {
44329       result = (float)(arg1)->GetFieldOfView();
44330     } catch (std::out_of_range& e) {
44331       {
44332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44333       };
44334     } catch (std::exception& e) {
44335       {
44336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44337       };
44338     } catch (...) {
44339       {
44340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44341       };
44342     }
44343   }
44344   jresult = result;
44345   return jresult;
44346 }
44347
44348
44349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
44350   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44351   float arg2 ;
44352
44353   arg1 = (Dali::CameraActor *)jarg1;
44354   arg2 = (float)jarg2;
44355   {
44356     try {
44357       (arg1)->SetAspectRatio(arg2);
44358     } catch (std::out_of_range& e) {
44359       {
44360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44361       };
44362     } catch (std::exception& e) {
44363       {
44364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44365       };
44366     } catch (...) {
44367       {
44368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44369       };
44370     }
44371   }
44372 }
44373
44374
44375 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
44376   float jresult ;
44377   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44378   float result;
44379
44380   arg1 = (Dali::CameraActor *)jarg1;
44381   {
44382     try {
44383       result = (float)(arg1)->GetAspectRatio();
44384     } catch (std::out_of_range& e) {
44385       {
44386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44387       };
44388     } catch (std::exception& e) {
44389       {
44390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44391       };
44392     } catch (...) {
44393       {
44394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44395       };
44396     }
44397   }
44398   jresult = result;
44399   return jresult;
44400 }
44401
44402
44403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
44404   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44405   float arg2 ;
44406
44407   arg1 = (Dali::CameraActor *)jarg1;
44408   arg2 = (float)jarg2;
44409   {
44410     try {
44411       (arg1)->SetNearClippingPlane(arg2);
44412     } catch (std::out_of_range& e) {
44413       {
44414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44415       };
44416     } catch (std::exception& e) {
44417       {
44418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44419       };
44420     } catch (...) {
44421       {
44422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44423       };
44424     }
44425   }
44426 }
44427
44428
44429 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
44430   float jresult ;
44431   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44432   float result;
44433
44434   arg1 = (Dali::CameraActor *)jarg1;
44435   {
44436     try {
44437       result = (float)(arg1)->GetNearClippingPlane();
44438     } catch (std::out_of_range& e) {
44439       {
44440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44441       };
44442     } catch (std::exception& e) {
44443       {
44444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44445       };
44446     } catch (...) {
44447       {
44448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44449       };
44450     }
44451   }
44452   jresult = result;
44453   return jresult;
44454 }
44455
44456
44457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
44458   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44459   float arg2 ;
44460
44461   arg1 = (Dali::CameraActor *)jarg1;
44462   arg2 = (float)jarg2;
44463   {
44464     try {
44465       (arg1)->SetFarClippingPlane(arg2);
44466     } catch (std::out_of_range& e) {
44467       {
44468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44469       };
44470     } catch (std::exception& e) {
44471       {
44472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44473       };
44474     } catch (...) {
44475       {
44476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44477       };
44478     }
44479   }
44480 }
44481
44482
44483 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
44484   float jresult ;
44485   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44486   float result;
44487
44488   arg1 = (Dali::CameraActor *)jarg1;
44489   {
44490     try {
44491       result = (float)(arg1)->GetFarClippingPlane();
44492     } catch (std::out_of_range& e) {
44493       {
44494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44495       };
44496     } catch (std::exception& e) {
44497       {
44498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44499       };
44500     } catch (...) {
44501       {
44502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44503       };
44504     }
44505   }
44506   jresult = result;
44507   return jresult;
44508 }
44509
44510
44511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
44512   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44513   Dali::Vector3 *arg2 = 0 ;
44514
44515   arg1 = (Dali::CameraActor *)jarg1;
44516   arg2 = (Dali::Vector3 *)jarg2;
44517   if (!arg2) {
44518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
44519     return ;
44520   }
44521   {
44522     try {
44523       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
44524     } catch (std::out_of_range& e) {
44525       {
44526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44527       };
44528     } catch (std::exception& e) {
44529       {
44530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44531       };
44532     } catch (...) {
44533       {
44534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44535       };
44536     }
44537   }
44538 }
44539
44540
44541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
44542   void * jresult ;
44543   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44544   Dali::Vector3 result;
44545
44546   arg1 = (Dali::CameraActor *)jarg1;
44547   {
44548     try {
44549       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
44550     } catch (std::out_of_range& e) {
44551       {
44552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44553       };
44554     } catch (std::exception& e) {
44555       {
44556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44557       };
44558     } catch (...) {
44559       {
44560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44561       };
44562     }
44563   }
44564   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
44565   return jresult;
44566 }
44567
44568
44569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
44570   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44571   bool arg2 ;
44572
44573   arg1 = (Dali::CameraActor *)jarg1;
44574   arg2 = jarg2 ? true : false;
44575   {
44576     try {
44577       (arg1)->SetInvertYAxis(arg2);
44578     } catch (std::out_of_range& e) {
44579       {
44580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44581       };
44582     } catch (std::exception& e) {
44583       {
44584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44585       };
44586     } catch (...) {
44587       {
44588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44589       };
44590     }
44591   }
44592 }
44593
44594
44595 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
44596   unsigned int jresult ;
44597   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44598   bool result;
44599
44600   arg1 = (Dali::CameraActor *)jarg1;
44601   {
44602     try {
44603       result = (bool)(arg1)->GetInvertYAxis();
44604     } catch (std::out_of_range& e) {
44605       {
44606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44607       };
44608     } catch (std::exception& e) {
44609       {
44610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44611       };
44612     } catch (...) {
44613       {
44614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44615       };
44616     }
44617   }
44618   jresult = result;
44619   return jresult;
44620 }
44621
44622
44623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
44624   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44625   Dali::Size *arg2 = 0 ;
44626
44627   arg1 = (Dali::CameraActor *)jarg1;
44628   arg2 = (Dali::Size *)jarg2;
44629   if (!arg2) {
44630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44631     return ;
44632   }
44633   {
44634     try {
44635       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
44636     } catch (std::out_of_range& e) {
44637       {
44638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44639       };
44640     } catch (std::exception& e) {
44641       {
44642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44643       };
44644     } catch (...) {
44645       {
44646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44647       };
44648     }
44649   }
44650 }
44651
44652
44653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
44654   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44655   Dali::Size *arg2 = 0 ;
44656
44657   arg1 = (Dali::CameraActor *)jarg1;
44658   arg2 = (Dali::Size *)jarg2;
44659   if (!arg2) {
44660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44661     return ;
44662   }
44663   {
44664     try {
44665       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
44666     } catch (std::out_of_range& e) {
44667       {
44668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44669       };
44670     } catch (std::exception& e) {
44671       {
44672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44673       };
44674     } catch (...) {
44675       {
44676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44677       };
44678     }
44679   }
44680 }
44681
44682
44683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
44684   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44685   float arg2 ;
44686   float arg3 ;
44687   float arg4 ;
44688   float arg5 ;
44689   float arg6 ;
44690   float arg7 ;
44691
44692   arg1 = (Dali::CameraActor *)jarg1;
44693   arg2 = (float)jarg2;
44694   arg3 = (float)jarg3;
44695   arg4 = (float)jarg4;
44696   arg5 = (float)jarg5;
44697   arg6 = (float)jarg6;
44698   arg7 = (float)jarg7;
44699   {
44700     try {
44701       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
44702     } catch (std::out_of_range& e) {
44703       {
44704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44705       };
44706     } catch (std::exception& e) {
44707       {
44708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44709       };
44710     } catch (...) {
44711       {
44712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44713       };
44714     }
44715   }
44716 }
44717
44718
44719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
44720   void * jresult ;
44721   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44722
44723   {
44724     try {
44725       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
44726     } catch (std::out_of_range& e) {
44727       {
44728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44729       };
44730     } catch (std::exception& e) {
44731       {
44732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44733       };
44734     } catch (...) {
44735       {
44736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44737       };
44738     }
44739   }
44740   jresult = (void *)result;
44741   return jresult;
44742 }
44743
44744
44745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
44746   void * jresult ;
44747   std::string arg1 ;
44748   Dali::Property::Value arg2 ;
44749   Dali::Property::Value *argp2 ;
44750   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44751
44752   if (!jarg1) {
44753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44754     return 0;
44755   }
44756   (&arg1)->assign(jarg1);
44757   argp2 = (Dali::Property::Value *)jarg2;
44758   if (!argp2) {
44759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
44760     return 0;
44761   }
44762   arg2 = *argp2;
44763   {
44764     try {
44765       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
44766     } catch (std::out_of_range& e) {
44767       {
44768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44769       };
44770     } catch (std::exception& e) {
44771       {
44772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44773       };
44774     } catch (...) {
44775       {
44776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44777       };
44778     }
44779   }
44780   jresult = (void *)result;
44781   return jresult;
44782 }
44783
44784
44785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
44786   void * jresult ;
44787   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
44788   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44789
44790   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44791   if (!arg1) {
44792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
44793     return 0;
44794   }
44795   {
44796     try {
44797       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);
44798     } catch (std::out_of_range& e) {
44799       {
44800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44801       };
44802     } catch (std::exception& e) {
44803       {
44804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44805       };
44806     } catch (...) {
44807       {
44808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44809       };
44810     }
44811   }
44812   jresult = (void *)result;
44813   return jresult;
44814 }
44815
44816
44817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
44818   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44819   std::string *arg2 = 0 ;
44820
44821   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44822   if (!jarg2) {
44823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44824     return ;
44825   }
44826   std::string arg2_str(jarg2);
44827   arg2 = &arg2_str;
44828   if (arg1) (arg1)->first = *arg2;
44829
44830   //argout typemap for const std::string&
44831
44832 }
44833
44834
44835 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
44836   char * jresult ;
44837   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44838   std::string *result = 0 ;
44839
44840   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44841   result = (std::string *) & ((arg1)->first);
44842   jresult = SWIG_csharp_string_callback(result->c_str());
44843   return jresult;
44844 }
44845
44846
44847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
44848   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44849   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
44850
44851   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44852   arg2 = (Dali::Property::Value *)jarg2;
44853   if (arg1) (arg1)->second = *arg2;
44854 }
44855
44856
44857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
44858   void * jresult ;
44859   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44860   Dali::Property::Value *result = 0 ;
44861
44862   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44863   result = (Dali::Property::Value *)& ((arg1)->second);
44864   jresult = (void *)result;
44865   return jresult;
44866 }
44867
44868
44869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
44870   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44871
44872   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44873   {
44874     try {
44875       delete arg1;
44876     } catch (std::out_of_range& e) {
44877       {
44878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44879       };
44880     } catch (std::exception& e) {
44881       {
44882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44883       };
44884     } catch (...) {
44885       {
44886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44887       };
44888     }
44889   }
44890 }
44891
44892
44893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
44894   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44895
44896   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44897   {
44898     try {
44899       (arg1)->clear();
44900     } catch (std::out_of_range& e) {
44901       {
44902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44903       };
44904     } catch (std::exception& e) {
44905       {
44906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44907       };
44908     } catch (...) {
44909       {
44910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44911       };
44912     }
44913   }
44914 }
44915
44916
44917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
44918   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44919   Dali::TouchPoint *arg2 = 0 ;
44920
44921   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44922   arg2 = (Dali::TouchPoint *)jarg2;
44923   if (!arg2) {
44924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
44925     return ;
44926   }
44927   {
44928     try {
44929       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
44930     } catch (std::out_of_range& e) {
44931       {
44932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44933       };
44934     } catch (std::exception& e) {
44935       {
44936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44937       };
44938     } catch (...) {
44939       {
44940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44941       };
44942     }
44943   }
44944 }
44945
44946
44947 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
44948   unsigned long jresult ;
44949   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44950   std::vector< Dali::TouchPoint >::size_type result;
44951
44952   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44953   {
44954     try {
44955       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
44956     } catch (std::out_of_range& e) {
44957       {
44958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44959       };
44960     } catch (std::exception& e) {
44961       {
44962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44963       };
44964     } catch (...) {
44965       {
44966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44967       };
44968     }
44969   }
44970   jresult = (unsigned long)result;
44971   return jresult;
44972 }
44973
44974
44975 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
44976   unsigned long jresult ;
44977   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44978   std::vector< Dali::TouchPoint >::size_type result;
44979
44980   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44981   {
44982     try {
44983       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
44984     } catch (std::out_of_range& e) {
44985       {
44986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44987       };
44988     } catch (std::exception& e) {
44989       {
44990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44991       };
44992     } catch (...) {
44993       {
44994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44995       };
44996     }
44997   }
44998   jresult = (unsigned long)result;
44999   return jresult;
45000 }
45001
45002
45003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
45004   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45005   std::vector< Dali::TouchPoint >::size_type arg2 ;
45006
45007   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45008   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
45009   {
45010     try {
45011       (arg1)->reserve(arg2);
45012     } catch (std::out_of_range& e) {
45013       {
45014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45015       };
45016     } catch (std::exception& e) {
45017       {
45018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45019       };
45020     } catch (...) {
45021       {
45022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45023       };
45024     }
45025   }
45026 }
45027
45028
45029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
45030   void * jresult ;
45031   std::vector< Dali::TouchPoint > *result = 0 ;
45032
45033   {
45034     try {
45035       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
45036     } catch (std::out_of_range& e) {
45037       {
45038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45039       };
45040     } catch (std::exception& e) {
45041       {
45042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45043       };
45044     } catch (...) {
45045       {
45046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45047       };
45048     }
45049   }
45050   jresult = (void *)result;
45051   return jresult;
45052 }
45053
45054
45055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
45056   void * jresult ;
45057   std::vector< Dali::TouchPoint > *arg1 = 0 ;
45058   std::vector< Dali::TouchPoint > *result = 0 ;
45059
45060   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45061   if (!arg1) {
45062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45063     return 0;
45064   }
45065   {
45066     try {
45067       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
45068     } catch (std::out_of_range& e) {
45069       {
45070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45071       };
45072     } catch (std::exception& e) {
45073       {
45074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45075       };
45076     } catch (...) {
45077       {
45078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45079       };
45080     }
45081   }
45082   jresult = (void *)result;
45083   return jresult;
45084 }
45085
45086
45087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
45088   void * jresult ;
45089   int arg1 ;
45090   std::vector< Dali::TouchPoint > *result = 0 ;
45091
45092   arg1 = (int)jarg1;
45093   {
45094     try {
45095       try {
45096         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
45097       }
45098       catch(std::out_of_range &_e) {
45099         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45100         return 0;
45101       }
45102
45103     } catch (std::out_of_range& e) {
45104       {
45105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45106       };
45107     } catch (std::exception& e) {
45108       {
45109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45110       };
45111     } catch (...) {
45112       {
45113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45114       };
45115     }
45116   }
45117   jresult = (void *)result;
45118   return jresult;
45119 }
45120
45121
45122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
45123   void * jresult ;
45124   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45125   int arg2 ;
45126   SwigValueWrapper< Dali::TouchPoint > result;
45127
45128   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45129   arg2 = (int)jarg2;
45130   {
45131     try {
45132       try {
45133         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
45134       }
45135       catch(std::out_of_range &_e) {
45136         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45137         return 0;
45138       }
45139
45140     } catch (std::out_of_range& e) {
45141       {
45142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45143       };
45144     } catch (std::exception& e) {
45145       {
45146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45147       };
45148     } catch (...) {
45149       {
45150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45151       };
45152     }
45153   }
45154   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
45155   return jresult;
45156 }
45157
45158
45159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
45160   void * jresult ;
45161   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45162   int arg2 ;
45163   Dali::TouchPoint *result = 0 ;
45164
45165   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45166   arg2 = (int)jarg2;
45167   {
45168     try {
45169       try {
45170         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
45171       }
45172       catch(std::out_of_range &_e) {
45173         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45174         return 0;
45175       }
45176
45177     } catch (std::out_of_range& e) {
45178       {
45179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45180       };
45181     } catch (std::exception& e) {
45182       {
45183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45184       };
45185     } catch (...) {
45186       {
45187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45188       };
45189     }
45190   }
45191   jresult = (void *)result;
45192   return jresult;
45193 }
45194
45195
45196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
45197   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45198   int arg2 ;
45199   Dali::TouchPoint *arg3 = 0 ;
45200
45201   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45202   arg2 = (int)jarg2;
45203   arg3 = (Dali::TouchPoint *)jarg3;
45204   if (!arg3) {
45205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45206     return ;
45207   }
45208   {
45209     try {
45210       try {
45211         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
45212       }
45213       catch(std::out_of_range &_e) {
45214         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45215         return ;
45216       }
45217
45218     } catch (std::out_of_range& e) {
45219       {
45220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45221       };
45222     } catch (std::exception& e) {
45223       {
45224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45225       };
45226     } catch (...) {
45227       {
45228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45229       };
45230     }
45231   }
45232 }
45233
45234
45235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
45236   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45237   std::vector< Dali::TouchPoint > *arg2 = 0 ;
45238
45239   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45240   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
45241   if (!arg2) {
45242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45243     return ;
45244   }
45245   {
45246     try {
45247       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
45248     } catch (std::out_of_range& e) {
45249       {
45250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45251       };
45252     } catch (std::exception& e) {
45253       {
45254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45255       };
45256     } catch (...) {
45257       {
45258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45259       };
45260     }
45261   }
45262 }
45263
45264
45265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
45266   void * jresult ;
45267   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45268   int arg2 ;
45269   int arg3 ;
45270   std::vector< Dali::TouchPoint > *result = 0 ;
45271
45272   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45273   arg2 = (int)jarg2;
45274   arg3 = (int)jarg3;
45275   {
45276     try {
45277       try {
45278         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
45279       }
45280       catch(std::out_of_range &_e) {
45281         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45282         return 0;
45283       }
45284       catch(std::invalid_argument &_e) {
45285         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45286         return 0;
45287       }
45288
45289     } catch (std::out_of_range& e) {
45290       {
45291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45292       };
45293     } catch (std::exception& e) {
45294       {
45295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45296       };
45297     } catch (...) {
45298       {
45299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45300       };
45301     }
45302   }
45303   jresult = (void *)result;
45304   return jresult;
45305 }
45306
45307
45308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
45309   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45310   int arg2 ;
45311   Dali::TouchPoint *arg3 = 0 ;
45312
45313   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45314   arg2 = (int)jarg2;
45315   arg3 = (Dali::TouchPoint *)jarg3;
45316   if (!arg3) {
45317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45318     return ;
45319   }
45320   {
45321     try {
45322       try {
45323         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
45324       }
45325       catch(std::out_of_range &_e) {
45326         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45327         return ;
45328       }
45329
45330     } catch (std::out_of_range& e) {
45331       {
45332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45333       };
45334     } catch (std::exception& e) {
45335       {
45336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45337       };
45338     } catch (...) {
45339       {
45340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45341       };
45342     }
45343   }
45344 }
45345
45346
45347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
45348   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45349   int arg2 ;
45350   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45351
45352   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45353   arg2 = (int)jarg2;
45354   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45355   if (!arg3) {
45356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45357     return ;
45358   }
45359   {
45360     try {
45361       try {
45362         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45363       }
45364       catch(std::out_of_range &_e) {
45365         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45366         return ;
45367       }
45368
45369     } catch (std::out_of_range& e) {
45370       {
45371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45372       };
45373     } catch (std::exception& e) {
45374       {
45375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45376       };
45377     } catch (...) {
45378       {
45379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45380       };
45381     }
45382   }
45383 }
45384
45385
45386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
45387   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45388   int arg2 ;
45389
45390   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45391   arg2 = (int)jarg2;
45392   {
45393     try {
45394       try {
45395         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
45396       }
45397       catch(std::out_of_range &_e) {
45398         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45399         return ;
45400       }
45401
45402     } catch (std::out_of_range& e) {
45403       {
45404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45405       };
45406     } catch (std::exception& e) {
45407       {
45408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45409       };
45410     } catch (...) {
45411       {
45412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45413       };
45414     }
45415   }
45416 }
45417
45418
45419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
45420   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45421   int arg2 ;
45422   int arg3 ;
45423
45424   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45425   arg2 = (int)jarg2;
45426   arg3 = (int)jarg3;
45427   {
45428     try {
45429       try {
45430         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
45431       }
45432       catch(std::out_of_range &_e) {
45433         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45434         return ;
45435       }
45436       catch(std::invalid_argument &_e) {
45437         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45438         return ;
45439       }
45440
45441     } catch (std::out_of_range& e) {
45442       {
45443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45444       };
45445     } catch (std::exception& e) {
45446       {
45447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45448       };
45449     } catch (...) {
45450       {
45451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45452       };
45453     }
45454   }
45455 }
45456
45457
45458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
45459   void * jresult ;
45460   Dali::TouchPoint *arg1 = 0 ;
45461   int arg2 ;
45462   std::vector< Dali::TouchPoint > *result = 0 ;
45463
45464   arg1 = (Dali::TouchPoint *)jarg1;
45465   if (!arg1) {
45466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45467     return 0;
45468   }
45469   arg2 = (int)jarg2;
45470   {
45471     try {
45472       try {
45473         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
45474       }
45475       catch(std::out_of_range &_e) {
45476         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45477         return 0;
45478       }
45479
45480     } catch (std::out_of_range& e) {
45481       {
45482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45483       };
45484     } catch (std::exception& e) {
45485       {
45486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45487       };
45488     } catch (...) {
45489       {
45490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45491       };
45492     }
45493   }
45494   jresult = (void *)result;
45495   return jresult;
45496 }
45497
45498
45499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
45500   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45501
45502   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45503   {
45504     try {
45505       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
45506     } catch (std::out_of_range& e) {
45507       {
45508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45509       };
45510     } catch (std::exception& e) {
45511       {
45512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45513       };
45514     } catch (...) {
45515       {
45516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45517       };
45518     }
45519   }
45520 }
45521
45522
45523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
45524   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45525   int arg2 ;
45526   int arg3 ;
45527
45528   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45529   arg2 = (int)jarg2;
45530   arg3 = (int)jarg3;
45531   {
45532     try {
45533       try {
45534         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
45535       }
45536       catch(std::out_of_range &_e) {
45537         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45538         return ;
45539       }
45540       catch(std::invalid_argument &_e) {
45541         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45542         return ;
45543       }
45544
45545     } catch (std::out_of_range& e) {
45546       {
45547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45548       };
45549     } catch (std::exception& e) {
45550       {
45551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45552       };
45553     } catch (...) {
45554       {
45555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45556       };
45557     }
45558   }
45559 }
45560
45561
45562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
45563   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45564   int arg2 ;
45565   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45566
45567   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45568   arg2 = (int)jarg2;
45569   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45570   if (!arg3) {
45571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45572     return ;
45573   }
45574   {
45575     try {
45576       try {
45577         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45578       }
45579       catch(std::out_of_range &_e) {
45580         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45581         return ;
45582       }
45583
45584     } catch (std::out_of_range& e) {
45585       {
45586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45587       };
45588     } catch (std::exception& e) {
45589       {
45590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45591       };
45592     } catch (...) {
45593       {
45594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45595       };
45596     }
45597   }
45598 }
45599
45600
45601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
45602   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45603
45604   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45605   {
45606     try {
45607       delete arg1;
45608     } catch (std::out_of_range& e) {
45609       {
45610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45611       };
45612     } catch (std::exception& e) {
45613       {
45614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45615       };
45616     } catch (...) {
45617       {
45618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45619       };
45620     }
45621   }
45622 }
45623
45624
45625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
45626   void * jresult ;
45627   Dali::Rect< int > *result = 0 ;
45628
45629   {
45630     try {
45631       result = (Dali::Rect< int > *)new Dali::Rect< int >();
45632     } catch (std::out_of_range& e) {
45633       {
45634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45635       };
45636     } catch (std::exception& e) {
45637       {
45638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45639       };
45640     } catch (...) {
45641       {
45642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45643       };
45644     }
45645   }
45646   jresult = (void *)result;
45647   return jresult;
45648 }
45649
45650
45651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
45652   void * jresult ;
45653   int arg1 ;
45654   int arg2 ;
45655   int arg3 ;
45656   int arg4 ;
45657   Dali::Rect< int > *result = 0 ;
45658
45659   arg1 = (int)jarg1;
45660   arg2 = (int)jarg2;
45661   arg3 = (int)jarg3;
45662   arg4 = (int)jarg4;
45663   {
45664     try {
45665       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
45666     } catch (std::out_of_range& e) {
45667       {
45668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45669       };
45670     } catch (std::exception& e) {
45671       {
45672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45673       };
45674     } catch (...) {
45675       {
45676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45677       };
45678     }
45679   }
45680   jresult = (void *)result;
45681   return jresult;
45682 }
45683
45684
45685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
45686   void * jresult ;
45687   Dali::Rect< int > *arg1 = 0 ;
45688   Dali::Rect< int > *result = 0 ;
45689
45690   arg1 = (Dali::Rect< int > *)jarg1;
45691   if (!arg1) {
45692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45693     return 0;
45694   }
45695   {
45696     try {
45697       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
45698     } catch (std::out_of_range& e) {
45699       {
45700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45701       };
45702     } catch (std::exception& e) {
45703       {
45704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45705       };
45706     } catch (...) {
45707       {
45708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45709       };
45710     }
45711   }
45712   jresult = (void *)result;
45713   return jresult;
45714 }
45715
45716
45717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
45718   void * jresult ;
45719   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45720   Dali::Rect< int > *arg2 = 0 ;
45721   Dali::Rect< int > *result = 0 ;
45722
45723   arg1 = (Dali::Rect< int > *)jarg1;
45724   arg2 = (Dali::Rect< int > *)jarg2;
45725   if (!arg2) {
45726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45727     return 0;
45728   }
45729   {
45730     try {
45731       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
45732     } catch (std::out_of_range& e) {
45733       {
45734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45735       };
45736     } catch (std::exception& e) {
45737       {
45738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45739       };
45740     } catch (...) {
45741       {
45742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45743       };
45744     }
45745   }
45746   jresult = (void *)result;
45747   return jresult;
45748 }
45749
45750
45751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
45752   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45753   int arg2 ;
45754   int arg3 ;
45755   int arg4 ;
45756   int arg5 ;
45757
45758   arg1 = (Dali::Rect< int > *)jarg1;
45759   arg2 = (int)jarg2;
45760   arg3 = (int)jarg3;
45761   arg4 = (int)jarg4;
45762   arg5 = (int)jarg5;
45763   {
45764     try {
45765       (arg1)->Set(arg2,arg3,arg4,arg5);
45766     } catch (std::out_of_range& e) {
45767       {
45768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45769       };
45770     } catch (std::exception& e) {
45771       {
45772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45773       };
45774     } catch (...) {
45775       {
45776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45777       };
45778     }
45779   }
45780 }
45781
45782
45783 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
45784   unsigned int jresult ;
45785   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45786   bool result;
45787
45788   arg1 = (Dali::Rect< int > *)jarg1;
45789   {
45790     try {
45791       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
45792     } catch (std::out_of_range& e) {
45793       {
45794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45795       };
45796     } catch (std::exception& e) {
45797       {
45798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45799       };
45800     } catch (...) {
45801       {
45802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45803       };
45804     }
45805   }
45806   jresult = result;
45807   return jresult;
45808 }
45809
45810
45811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
45812   int jresult ;
45813   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45814   int result;
45815
45816   arg1 = (Dali::Rect< int > *)jarg1;
45817   {
45818     try {
45819       result = (int)((Dali::Rect< int > const *)arg1)->Left();
45820     } catch (std::out_of_range& e) {
45821       {
45822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45823       };
45824     } catch (std::exception& e) {
45825       {
45826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45827       };
45828     } catch (...) {
45829       {
45830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45831       };
45832     }
45833   }
45834   jresult = result;
45835   return jresult;
45836 }
45837
45838
45839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
45840   int jresult ;
45841   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45842   int result;
45843
45844   arg1 = (Dali::Rect< int > *)jarg1;
45845   {
45846     try {
45847       result = (int)((Dali::Rect< int > const *)arg1)->Right();
45848     } catch (std::out_of_range& e) {
45849       {
45850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45851       };
45852     } catch (std::exception& e) {
45853       {
45854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45855       };
45856     } catch (...) {
45857       {
45858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45859       };
45860     }
45861   }
45862   jresult = result;
45863   return jresult;
45864 }
45865
45866
45867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
45868   int jresult ;
45869   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45870   int result;
45871
45872   arg1 = (Dali::Rect< int > *)jarg1;
45873   {
45874     try {
45875       result = (int)((Dali::Rect< int > const *)arg1)->Top();
45876     } catch (std::out_of_range& e) {
45877       {
45878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45879       };
45880     } catch (std::exception& e) {
45881       {
45882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45883       };
45884     } catch (...) {
45885       {
45886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45887       };
45888     }
45889   }
45890   jresult = result;
45891   return jresult;
45892 }
45893
45894
45895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
45896   int jresult ;
45897   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45898   int result;
45899
45900   arg1 = (Dali::Rect< int > *)jarg1;
45901   {
45902     try {
45903       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
45904     } catch (std::out_of_range& e) {
45905       {
45906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45907       };
45908     } catch (std::exception& e) {
45909       {
45910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45911       };
45912     } catch (...) {
45913       {
45914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45915       };
45916     }
45917   }
45918   jresult = result;
45919   return jresult;
45920 }
45921
45922
45923 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
45924   int jresult ;
45925   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45926   int result;
45927
45928   arg1 = (Dali::Rect< int > *)jarg1;
45929   {
45930     try {
45931       result = (int)((Dali::Rect< int > const *)arg1)->Area();
45932     } catch (std::out_of_range& e) {
45933       {
45934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45935       };
45936     } catch (std::exception& e) {
45937       {
45938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45939       };
45940     } catch (...) {
45941       {
45942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45943       };
45944     }
45945   }
45946   jresult = result;
45947   return jresult;
45948 }
45949
45950
45951 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
45952   unsigned int jresult ;
45953   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45954   Dali::Rect< int > *arg2 = 0 ;
45955   bool result;
45956
45957   arg1 = (Dali::Rect< int > *)jarg1;
45958   arg2 = (Dali::Rect< int > *)jarg2;
45959   if (!arg2) {
45960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45961     return 0;
45962   }
45963   {
45964     try {
45965       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
45966     } catch (std::out_of_range& e) {
45967       {
45968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45969       };
45970     } catch (std::exception& e) {
45971       {
45972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45973       };
45974     } catch (...) {
45975       {
45976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45977       };
45978     }
45979   }
45980   jresult = result;
45981   return jresult;
45982 }
45983
45984
45985 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
45986   unsigned int jresult ;
45987   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45988   Dali::Rect< int > *arg2 = 0 ;
45989   bool result;
45990
45991   arg1 = (Dali::Rect< int > *)jarg1;
45992   arg2 = (Dali::Rect< int > *)jarg2;
45993   if (!arg2) {
45994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45995     return 0;
45996   }
45997   {
45998     try {
45999       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
46000     } catch (std::out_of_range& e) {
46001       {
46002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46003       };
46004     } catch (std::exception& e) {
46005       {
46006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46007       };
46008     } catch (...) {
46009       {
46010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46011       };
46012     }
46013   }
46014   jresult = result;
46015   return jresult;
46016 }
46017
46018
46019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
46020   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46021   int arg2 ;
46022
46023   arg1 = (Dali::Rect< int > *)jarg1;
46024   arg2 = (int)jarg2;
46025   if (arg1) (arg1)->x = arg2;
46026 }
46027
46028
46029 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
46030   int jresult ;
46031   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46032   int result;
46033
46034   arg1 = (Dali::Rect< int > *)jarg1;
46035   result = (int) ((arg1)->x);
46036   jresult = result;
46037   return jresult;
46038 }
46039
46040
46041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
46042   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46043   int arg2 ;
46044
46045   arg1 = (Dali::Rect< int > *)jarg1;
46046   arg2 = (int)jarg2;
46047   if (arg1) (arg1)->left = arg2;
46048 }
46049
46050
46051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
46052   int jresult ;
46053   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46054   int result;
46055
46056   arg1 = (Dali::Rect< int > *)jarg1;
46057   result = (int) ((arg1)->left);
46058   jresult = result;
46059   return jresult;
46060 }
46061
46062
46063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
46064   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46065   int arg2 ;
46066
46067   arg1 = (Dali::Rect< int > *)jarg1;
46068   arg2 = (int)jarg2;
46069   if (arg1) (arg1)->y = arg2;
46070 }
46071
46072
46073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
46074   int jresult ;
46075   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46076   int result;
46077
46078   arg1 = (Dali::Rect< int > *)jarg1;
46079   result = (int) ((arg1)->y);
46080   jresult = result;
46081   return jresult;
46082 }
46083
46084
46085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
46086   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46087   int arg2 ;
46088
46089   arg1 = (Dali::Rect< int > *)jarg1;
46090   arg2 = (int)jarg2;
46091   if (arg1) (arg1)->right = arg2;
46092 }
46093
46094
46095 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
46096   int jresult ;
46097   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46098   int result;
46099
46100   arg1 = (Dali::Rect< int > *)jarg1;
46101   result = (int) ((arg1)->right);
46102   jresult = result;
46103   return jresult;
46104 }
46105
46106
46107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
46108   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46109   int arg2 ;
46110
46111   arg1 = (Dali::Rect< int > *)jarg1;
46112   arg2 = (int)jarg2;
46113   if (arg1) (arg1)->width = arg2;
46114 }
46115
46116
46117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
46118   int jresult ;
46119   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46120   int result;
46121
46122   arg1 = (Dali::Rect< int > *)jarg1;
46123   result = (int) ((arg1)->width);
46124   jresult = result;
46125   return jresult;
46126 }
46127
46128
46129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
46130   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46131   int arg2 ;
46132
46133   arg1 = (Dali::Rect< int > *)jarg1;
46134   arg2 = (int)jarg2;
46135   if (arg1) (arg1)->bottom = arg2;
46136 }
46137
46138
46139 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
46140   int jresult ;
46141   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46142   int result;
46143
46144   arg1 = (Dali::Rect< int > *)jarg1;
46145   result = (int) ((arg1)->bottom);
46146   jresult = result;
46147   return jresult;
46148 }
46149
46150
46151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
46152   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46153   int arg2 ;
46154
46155   arg1 = (Dali::Rect< int > *)jarg1;
46156   arg2 = (int)jarg2;
46157   if (arg1) (arg1)->height = arg2;
46158 }
46159
46160
46161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
46162   int jresult ;
46163   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46164   int result;
46165
46166   arg1 = (Dali::Rect< int > *)jarg1;
46167   result = (int) ((arg1)->height);
46168   jresult = result;
46169   return jresult;
46170 }
46171
46172
46173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
46174   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46175   int arg2 ;
46176
46177   arg1 = (Dali::Rect< int > *)jarg1;
46178   arg2 = (int)jarg2;
46179   if (arg1) (arg1)->top = arg2;
46180 }
46181
46182
46183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
46184   int jresult ;
46185   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46186   int result;
46187
46188   arg1 = (Dali::Rect< int > *)jarg1;
46189   result = (int) ((arg1)->top);
46190   jresult = result;
46191   return jresult;
46192 }
46193
46194
46195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
46196   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46197
46198   arg1 = (Dali::Rect< int > *)jarg1;
46199   {
46200     try {
46201       delete arg1;
46202     } catch (std::out_of_range& e) {
46203       {
46204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46205       };
46206     } catch (std::exception& e) {
46207       {
46208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46209       };
46210     } catch (...) {
46211       {
46212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46213       };
46214     }
46215   }
46216 }
46217
46218
46219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
46220   void * jresult ;
46221   Dali::Rect< float > *result = 0 ;
46222
46223   {
46224     try {
46225       result = (Dali::Rect< float > *)new Dali::Rect< float >();
46226     } catch (std::out_of_range& e) {
46227       {
46228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46229       };
46230     } catch (std::exception& e) {
46231       {
46232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46233       };
46234     } catch (...) {
46235       {
46236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46237       };
46238     }
46239   }
46240   jresult = (void *)result;
46241   return jresult;
46242 }
46243
46244
46245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
46246   void * jresult ;
46247   float arg1 ;
46248   float arg2 ;
46249   float arg3 ;
46250   float arg4 ;
46251   Dali::Rect< float > *result = 0 ;
46252
46253   arg1 = (float)jarg1;
46254   arg2 = (float)jarg2;
46255   arg3 = (float)jarg3;
46256   arg4 = (float)jarg4;
46257   {
46258     try {
46259       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
46260     } catch (std::out_of_range& e) {
46261       {
46262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46263       };
46264     } catch (std::exception& e) {
46265       {
46266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46267       };
46268     } catch (...) {
46269       {
46270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46271       };
46272     }
46273   }
46274   jresult = (void *)result;
46275   return jresult;
46276 }
46277
46278
46279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
46280   void * jresult ;
46281   Dali::Rect< float > *arg1 = 0 ;
46282   Dali::Rect< float > *result = 0 ;
46283
46284   arg1 = (Dali::Rect< float > *)jarg1;
46285   if (!arg1) {
46286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
46287     return 0;
46288   }
46289   {
46290     try {
46291       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
46292     } catch (std::out_of_range& e) {
46293       {
46294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46295       };
46296     } catch (std::exception& e) {
46297       {
46298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46299       };
46300     } catch (...) {
46301       {
46302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46303       };
46304     }
46305   }
46306   jresult = (void *)result;
46307   return jresult;
46308 }
46309
46310
46311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
46312   void * jresult ;
46313   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46314   Dali::Rect< float > *arg2 = 0 ;
46315   Dali::Rect< float > *result = 0 ;
46316
46317   arg1 = (Dali::Rect< float > *)jarg1;
46318   arg2 = (Dali::Rect< float > *)jarg2;
46319   if (!arg2) {
46320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
46321     return 0;
46322   }
46323   {
46324     try {
46325       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
46326     } catch (std::out_of_range& e) {
46327       {
46328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46329       };
46330     } catch (std::exception& e) {
46331       {
46332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46333       };
46334     } catch (...) {
46335       {
46336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46337       };
46338     }
46339   }
46340   jresult = (void *)result;
46341   return jresult;
46342 }
46343
46344
46345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
46346   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46347   float arg2 ;
46348   float arg3 ;
46349   float arg4 ;
46350   float arg5 ;
46351
46352   arg1 = (Dali::Rect< float > *)jarg1;
46353   arg2 = (float)jarg2;
46354   arg3 = (float)jarg3;
46355   arg4 = (float)jarg4;
46356   arg5 = (float)jarg5;
46357   {
46358     try {
46359       (arg1)->Set(arg2,arg3,arg4,arg5);
46360     } catch (std::out_of_range& e) {
46361       {
46362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46363       };
46364     } catch (std::exception& e) {
46365       {
46366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46367       };
46368     } catch (...) {
46369       {
46370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46371       };
46372     }
46373   }
46374 }
46375
46376
46377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_x_set(void * jarg1, float jarg2) {
46378   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46379   float arg2 ;
46380
46381   arg1 = (Dali::Rect< float > *)jarg1;
46382   arg2 = (float)jarg2;
46383   if (arg1) (arg1)->x = arg2;
46384 }
46385
46386
46387 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_x_get(void * jarg1) {
46388   float jresult ;
46389   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46390   float result;
46391
46392   arg1 = (Dali::Rect< float > *)jarg1;
46393   result = (float) ((arg1)->x);
46394   jresult = result;
46395   return jresult;
46396 }
46397
46398
46399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
46400   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46401   float arg2 ;
46402
46403   arg1 = (Dali::Rect< float > *)jarg1;
46404   arg2 = (float)jarg2;
46405   if (arg1) (arg1)->left = arg2;
46406 }
46407
46408
46409 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
46410   float jresult ;
46411   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46412   float result;
46413
46414   arg1 = (Dali::Rect< float > *)jarg1;
46415   result = (float) ((arg1)->left);
46416   jresult = result;
46417   return jresult;
46418 }
46419
46420
46421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_y_set(void * jarg1, float jarg2) {
46422   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46423   float arg2 ;
46424
46425   arg1 = (Dali::Rect< float > *)jarg1;
46426   arg2 = (float)jarg2;
46427   if (arg1) (arg1)->y = arg2;
46428 }
46429
46430
46431 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_y_get(void * jarg1) {
46432   float jresult ;
46433   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46434   float result;
46435
46436   arg1 = (Dali::Rect< float > *)jarg1;
46437   result = (float) ((arg1)->y);
46438   jresult = result;
46439   return jresult;
46440 }
46441
46442
46443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
46444   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46445   float arg2 ;
46446
46447   arg1 = (Dali::Rect< float > *)jarg1;
46448   arg2 = (float)jarg2;
46449   if (arg1) (arg1)->right = arg2;
46450 }
46451
46452
46453 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
46454   float jresult ;
46455   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46456   float result;
46457
46458   arg1 = (Dali::Rect< float > *)jarg1;
46459   result = (float) ((arg1)->right);
46460   jresult = result;
46461   return jresult;
46462 }
46463
46464
46465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_width_set(void * jarg1, float jarg2) {
46466   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46467   float arg2 ;
46468
46469   arg1 = (Dali::Rect< float > *)jarg1;
46470   arg2 = (float)jarg2;
46471   if (arg1) (arg1)->width = arg2;
46472 }
46473
46474
46475 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_width_get(void * jarg1) {
46476   float jresult ;
46477   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46478   float result;
46479
46480   arg1 = (Dali::Rect< float > *)jarg1;
46481   result = (float) ((arg1)->width);
46482   jresult = result;
46483   return jresult;
46484 }
46485
46486
46487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
46488   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46489   float arg2 ;
46490
46491   arg1 = (Dali::Rect< float > *)jarg1;
46492   arg2 = (float)jarg2;
46493   if (arg1) (arg1)->bottom = arg2;
46494 }
46495
46496
46497 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
46498   float jresult ;
46499   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46500   float result;
46501
46502   arg1 = (Dali::Rect< float > *)jarg1;
46503   result = (float) ((arg1)->bottom);
46504   jresult = result;
46505   return jresult;
46506 }
46507
46508
46509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_height_set(void * jarg1, float jarg2) {
46510   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46511   float arg2 ;
46512
46513   arg1 = (Dali::Rect< float > *)jarg1;
46514   arg2 = (float)jarg2;
46515   if (arg1) (arg1)->height = arg2;
46516 }
46517
46518
46519 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_height_get(void * jarg1) {
46520   float jresult ;
46521   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46522   float result;
46523
46524   arg1 = (Dali::Rect< float > *)jarg1;
46525   result = (float) ((arg1)->height);
46526   jresult = result;
46527   return jresult;
46528 }
46529
46530
46531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
46532   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46533   float arg2 ;
46534
46535   arg1 = (Dali::Rect< float > *)jarg1;
46536   arg2 = (float)jarg2;
46537   if (arg1) (arg1)->top = arg2;
46538 }
46539
46540
46541 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
46542   float jresult ;
46543   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46544   float result;
46545
46546   arg1 = (Dali::Rect< float > *)jarg1;
46547   result = (float) ((arg1)->top);
46548   jresult = result;
46549   return jresult;
46550 }
46551
46552
46553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
46554   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46555
46556   arg1 = (Dali::Rect< float > *)jarg1;
46557   {
46558     try {
46559       delete arg1;
46560     } catch (std::out_of_range& e) {
46561       {
46562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46563       };
46564     } catch (std::exception& e) {
46565       {
46566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46567       };
46568     } catch (...) {
46569       {
46570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46571       };
46572     }
46573   }
46574 }
46575
46576
46577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
46578   int jresult ;
46579   int result;
46580
46581   result = (int)Dali::Vector< int >::BaseType;
46582   jresult = (int)result;
46583   return jresult;
46584 }
46585
46586
46587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
46588   void * jresult ;
46589   Dali::Vector< int > *result = 0 ;
46590
46591   {
46592     try {
46593       result = (Dali::Vector< int > *)new Dali::Vector< int >();
46594     } catch (std::out_of_range& e) {
46595       {
46596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46597       };
46598     } catch (std::exception& e) {
46599       {
46600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46601       };
46602     } catch (...) {
46603       {
46604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46605       };
46606     }
46607   }
46608   jresult = (void *)result;
46609   return jresult;
46610 }
46611
46612
46613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
46614   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46615
46616   arg1 = (Dali::Vector< int > *)jarg1;
46617   {
46618     try {
46619       delete arg1;
46620     } catch (std::out_of_range& e) {
46621       {
46622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46623       };
46624     } catch (std::exception& e) {
46625       {
46626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46627       };
46628     } catch (...) {
46629       {
46630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46631       };
46632     }
46633   }
46634 }
46635
46636
46637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
46638   void * jresult ;
46639   Dali::Vector< int > *arg1 = 0 ;
46640   Dali::Vector< int > *result = 0 ;
46641
46642   arg1 = (Dali::Vector< int > *)jarg1;
46643   if (!arg1) {
46644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
46645     return 0;
46646   }
46647   {
46648     try {
46649       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
46650     } catch (std::out_of_range& e) {
46651       {
46652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46653       };
46654     } catch (std::exception& e) {
46655       {
46656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46657       };
46658     } catch (...) {
46659       {
46660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46661       };
46662     }
46663   }
46664   jresult = (void *)result;
46665   return jresult;
46666 }
46667
46668
46669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
46670   void * jresult ;
46671   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46672   Dali::Vector< int > *arg2 = 0 ;
46673   Dali::Vector< int > *result = 0 ;
46674
46675   arg1 = (Dali::Vector< int > *)jarg1;
46676   arg2 = (Dali::Vector< int > *)jarg2;
46677   if (!arg2) {
46678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
46679     return 0;
46680   }
46681   {
46682     try {
46683       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
46684     } catch (std::out_of_range& e) {
46685       {
46686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46687       };
46688     } catch (std::exception& e) {
46689       {
46690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46691       };
46692     } catch (...) {
46693       {
46694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46695       };
46696     }
46697   }
46698   jresult = (void *)result;
46699   return jresult;
46700 }
46701
46702
46703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
46704   void * jresult ;
46705   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46706   Dali::Vector< int >::Iterator result;
46707
46708   arg1 = (Dali::Vector< int > *)jarg1;
46709   {
46710     try {
46711       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
46712     } catch (std::out_of_range& e) {
46713       {
46714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46715       };
46716     } catch (std::exception& e) {
46717       {
46718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46719       };
46720     } catch (...) {
46721       {
46722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46723       };
46724     }
46725   }
46726   jresult = (void *)result;
46727   return jresult;
46728 }
46729
46730
46731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
46732   void * jresult ;
46733   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46734   Dali::Vector< int >::Iterator result;
46735
46736   arg1 = (Dali::Vector< int > *)jarg1;
46737   {
46738     try {
46739       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
46740     } catch (std::out_of_range& e) {
46741       {
46742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46743       };
46744     } catch (std::exception& e) {
46745       {
46746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46747       };
46748     } catch (...) {
46749       {
46750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46751       };
46752     }
46753   }
46754   jresult = (void *)result;
46755   return jresult;
46756 }
46757
46758
46759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
46760   void * jresult ;
46761   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46762   Dali::Vector< int >::SizeType arg2 ;
46763   Dali::Vector< int >::ItemType *result = 0 ;
46764
46765   arg1 = (Dali::Vector< int > *)jarg1;
46766   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46767   {
46768     try {
46769       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
46770     } catch (std::out_of_range& e) {
46771       {
46772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46773       };
46774     } catch (std::exception& e) {
46775       {
46776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46777       };
46778     } catch (...) {
46779       {
46780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46781       };
46782     }
46783   }
46784   jresult = (void *)result;
46785   return jresult;
46786 }
46787
46788
46789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
46790   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46791   Dali::Vector< int >::ItemType *arg2 = 0 ;
46792   Dali::Vector< int >::ItemType temp2 ;
46793
46794   arg1 = (Dali::Vector< int > *)jarg1;
46795   temp2 = (Dali::Vector< int >::ItemType)jarg2;
46796   arg2 = &temp2;
46797   {
46798     try {
46799       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
46800     } catch (std::out_of_range& e) {
46801       {
46802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46803       };
46804     } catch (std::exception& e) {
46805       {
46806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46807       };
46808     } catch (...) {
46809       {
46810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46811       };
46812     }
46813   }
46814 }
46815
46816
46817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
46818   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46819   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46820   Dali::Vector< int >::ItemType *arg3 = 0 ;
46821   Dali::Vector< int >::ItemType temp3 ;
46822
46823   arg1 = (Dali::Vector< int > *)jarg1;
46824   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46825   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46826   arg3 = &temp3;
46827   {
46828     try {
46829       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
46830     } catch (std::out_of_range& e) {
46831       {
46832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46833       };
46834     } catch (std::exception& e) {
46835       {
46836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46837       };
46838     } catch (...) {
46839       {
46840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46841       };
46842     }
46843   }
46844 }
46845
46846
46847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
46848   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46849   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46850   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
46851   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
46852
46853   arg1 = (Dali::Vector< int > *)jarg1;
46854   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46855   arg3 = (Dali::Vector< int >::Iterator)jarg3;
46856   arg4 = (Dali::Vector< int >::Iterator)jarg4;
46857   {
46858     try {
46859       (arg1)->Insert(arg2,arg3,arg4);
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 void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
46878   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46879   Dali::Vector< int >::SizeType arg2 ;
46880
46881   arg1 = (Dali::Vector< int > *)jarg1;
46882   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46883   {
46884     try {
46885       (arg1)->Reserve(arg2);
46886     } catch (std::out_of_range& e) {
46887       {
46888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46889       };
46890     } catch (std::exception& e) {
46891       {
46892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46893       };
46894     } catch (...) {
46895       {
46896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46897       };
46898     }
46899   }
46900 }
46901
46902
46903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
46904   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46905   Dali::Vector< int >::SizeType arg2 ;
46906
46907   arg1 = (Dali::Vector< int > *)jarg1;
46908   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46909   {
46910     try {
46911       (arg1)->Resize(arg2);
46912     } catch (std::out_of_range& e) {
46913       {
46914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46915       };
46916     } catch (std::exception& e) {
46917       {
46918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46919       };
46920     } catch (...) {
46921       {
46922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46923       };
46924     }
46925   }
46926 }
46927
46928
46929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
46930   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46931   Dali::Vector< int >::SizeType arg2 ;
46932   Dali::Vector< int >::ItemType *arg3 = 0 ;
46933   Dali::Vector< int >::ItemType temp3 ;
46934
46935   arg1 = (Dali::Vector< int > *)jarg1;
46936   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46937   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46938   arg3 = &temp3;
46939   {
46940     try {
46941       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
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_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
46960   void * jresult ;
46961   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46962   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46963   Dali::Vector< int >::Iterator result;
46964
46965   arg1 = (Dali::Vector< int > *)jarg1;
46966   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46967   {
46968     try {
46969       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
46970     } catch (std::out_of_range& e) {
46971       {
46972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46973       };
46974     } catch (std::exception& e) {
46975       {
46976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46977       };
46978     } catch (...) {
46979       {
46980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46981       };
46982     }
46983   }
46984   jresult = (void *)result;
46985   return jresult;
46986 }
46987
46988
46989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
46990   void * jresult ;
46991   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46992   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46993   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
46994   Dali::Vector< int >::Iterator result;
46995
46996   arg1 = (Dali::Vector< int > *)jarg1;
46997   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46998   arg3 = (Dali::Vector< int >::Iterator)jarg3;
46999   {
47000     try {
47001       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
47002     } catch (std::out_of_range& e) {
47003       {
47004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47005       };
47006     } catch (std::exception& e) {
47007       {
47008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47009       };
47010     } catch (...) {
47011       {
47012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47013       };
47014     }
47015   }
47016   jresult = (void *)result;
47017   return jresult;
47018 }
47019
47020
47021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
47022   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47023   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
47024
47025   arg1 = (Dali::Vector< int > *)jarg1;
47026   arg2 = (Dali::Vector< int >::Iterator)jarg2;
47027   {
47028     try {
47029       (arg1)->Remove(arg2);
47030     } catch (std::out_of_range& e) {
47031       {
47032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47033       };
47034     } catch (std::exception& e) {
47035       {
47036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47037       };
47038     } catch (...) {
47039       {
47040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47041       };
47042     }
47043   }
47044 }
47045
47046
47047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
47048   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47049   Dali::Vector< int > *arg2 = 0 ;
47050
47051   arg1 = (Dali::Vector< int > *)jarg1;
47052   arg2 = (Dali::Vector< int > *)jarg2;
47053   if (!arg2) {
47054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
47055     return ;
47056   }
47057   {
47058     try {
47059       (arg1)->Swap(*arg2);
47060     } catch (std::out_of_range& e) {
47061       {
47062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47063       };
47064     } catch (std::exception& e) {
47065       {
47066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47067       };
47068     } catch (...) {
47069       {
47070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47071       };
47072     }
47073   }
47074 }
47075
47076
47077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
47078   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47079
47080   arg1 = (Dali::Vector< int > *)jarg1;
47081   {
47082     try {
47083       (arg1)->Clear();
47084     } catch (std::out_of_range& e) {
47085       {
47086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47087       };
47088     } catch (std::exception& e) {
47089       {
47090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47091       };
47092     } catch (...) {
47093       {
47094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47095       };
47096     }
47097   }
47098 }
47099
47100
47101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
47102   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47103
47104   arg1 = (Dali::Vector< int > *)jarg1;
47105   {
47106     try {
47107       (arg1)->Release();
47108     } catch (std::out_of_range& e) {
47109       {
47110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47111       };
47112     } catch (std::exception& e) {
47113       {
47114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47115       };
47116     } catch (...) {
47117       {
47118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47119       };
47120     }
47121   }
47122 }
47123
47124
47125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
47126   int jresult ;
47127   int result;
47128
47129   result = (int)Dali::Vector< float >::BaseType;
47130   jresult = (int)result;
47131   return jresult;
47132 }
47133
47134
47135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
47136   void * jresult ;
47137   Dali::Vector< float > *result = 0 ;
47138
47139   {
47140     try {
47141       result = (Dali::Vector< float > *)new Dali::Vector< float >();
47142     } catch (std::out_of_range& e) {
47143       {
47144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47145       };
47146     } catch (std::exception& e) {
47147       {
47148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47149       };
47150     } catch (...) {
47151       {
47152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47153       };
47154     }
47155   }
47156   jresult = (void *)result;
47157   return jresult;
47158 }
47159
47160
47161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
47162   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47163
47164   arg1 = (Dali::Vector< float > *)jarg1;
47165   {
47166     try {
47167       delete arg1;
47168     } catch (std::out_of_range& e) {
47169       {
47170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47171       };
47172     } catch (std::exception& e) {
47173       {
47174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47175       };
47176     } catch (...) {
47177       {
47178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47179       };
47180     }
47181   }
47182 }
47183
47184
47185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
47186   void * jresult ;
47187   Dali::Vector< float > *arg1 = 0 ;
47188   Dali::Vector< float > *result = 0 ;
47189
47190   arg1 = (Dali::Vector< float > *)jarg1;
47191   if (!arg1) {
47192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
47193     return 0;
47194   }
47195   {
47196     try {
47197       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
47198     } catch (std::out_of_range& e) {
47199       {
47200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47201       };
47202     } catch (std::exception& e) {
47203       {
47204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47205       };
47206     } catch (...) {
47207       {
47208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47209       };
47210     }
47211   }
47212   jresult = (void *)result;
47213   return jresult;
47214 }
47215
47216
47217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
47218   void * jresult ;
47219   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47220   Dali::Vector< float > *arg2 = 0 ;
47221   Dali::Vector< float > *result = 0 ;
47222
47223   arg1 = (Dali::Vector< float > *)jarg1;
47224   arg2 = (Dali::Vector< float > *)jarg2;
47225   if (!arg2) {
47226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
47227     return 0;
47228   }
47229   {
47230     try {
47231       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
47232     } catch (std::out_of_range& e) {
47233       {
47234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47235       };
47236     } catch (std::exception& e) {
47237       {
47238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47239       };
47240     } catch (...) {
47241       {
47242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47243       };
47244     }
47245   }
47246   jresult = (void *)result;
47247   return jresult;
47248 }
47249
47250
47251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
47252   void * jresult ;
47253   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47254   Dali::Vector< float >::Iterator result;
47255
47256   arg1 = (Dali::Vector< float > *)jarg1;
47257   {
47258     try {
47259       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
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 = (void *)result;
47275   return jresult;
47276 }
47277
47278
47279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
47280   void * jresult ;
47281   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47282   Dali::Vector< float >::Iterator result;
47283
47284   arg1 = (Dali::Vector< float > *)jarg1;
47285   {
47286     try {
47287       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
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 = (void *)result;
47303   return jresult;
47304 }
47305
47306
47307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47308   void * jresult ;
47309   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47310   Dali::Vector< float >::SizeType arg2 ;
47311   Dali::Vector< float >::ItemType *result = 0 ;
47312
47313   arg1 = (Dali::Vector< float > *)jarg1;
47314   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47315   {
47316     try {
47317       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
47318     } catch (std::out_of_range& e) {
47319       {
47320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47321       };
47322     } catch (std::exception& e) {
47323       {
47324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47325       };
47326     } catch (...) {
47327       {
47328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47329       };
47330     }
47331   }
47332   jresult = (void *)result;
47333   return jresult;
47334 }
47335
47336
47337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
47338   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47339   Dali::Vector< float >::ItemType *arg2 = 0 ;
47340   Dali::Vector< float >::ItemType temp2 ;
47341
47342   arg1 = (Dali::Vector< float > *)jarg1;
47343   temp2 = (Dali::Vector< float >::ItemType)jarg2;
47344   arg2 = &temp2;
47345   {
47346     try {
47347       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
47348     } catch (std::out_of_range& e) {
47349       {
47350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47351       };
47352     } catch (std::exception& e) {
47353       {
47354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47355       };
47356     } catch (...) {
47357       {
47358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47359       };
47360     }
47361   }
47362 }
47363
47364
47365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
47366   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47367   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47368   Dali::Vector< float >::ItemType *arg3 = 0 ;
47369   Dali::Vector< float >::ItemType temp3 ;
47370
47371   arg1 = (Dali::Vector< float > *)jarg1;
47372   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47373   temp3 = (Dali::Vector< float >::ItemType)jarg3;
47374   arg3 = &temp3;
47375   {
47376     try {
47377       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
47378     } catch (std::out_of_range& e) {
47379       {
47380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47381       };
47382     } catch (std::exception& e) {
47383       {
47384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47385       };
47386     } catch (...) {
47387       {
47388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47389       };
47390     }
47391   }
47392 }
47393
47394
47395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
47396   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47397   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47398   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
47399   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
47400
47401   arg1 = (Dali::Vector< float > *)jarg1;
47402   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47403   arg3 = (Dali::Vector< float >::Iterator)jarg3;
47404   arg4 = (Dali::Vector< float >::Iterator)jarg4;
47405   {
47406     try {
47407       (arg1)->Insert(arg2,arg3,arg4);
47408     } catch (std::out_of_range& e) {
47409       {
47410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47411       };
47412     } catch (std::exception& e) {
47413       {
47414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47415       };
47416     } catch (...) {
47417       {
47418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47419       };
47420     }
47421   }
47422 }
47423
47424
47425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
47426   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47427   Dali::Vector< float >::SizeType arg2 ;
47428
47429   arg1 = (Dali::Vector< float > *)jarg1;
47430   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47431   {
47432     try {
47433       (arg1)->Reserve(arg2);
47434     } catch (std::out_of_range& e) {
47435       {
47436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47437       };
47438     } catch (std::exception& e) {
47439       {
47440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47441       };
47442     } catch (...) {
47443       {
47444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47445       };
47446     }
47447   }
47448 }
47449
47450
47451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47452   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47453   Dali::Vector< float >::SizeType arg2 ;
47454
47455   arg1 = (Dali::Vector< float > *)jarg1;
47456   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47457   {
47458     try {
47459       (arg1)->Resize(arg2);
47460     } catch (std::out_of_range& e) {
47461       {
47462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47463       };
47464     } catch (std::exception& e) {
47465       {
47466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47467       };
47468     } catch (...) {
47469       {
47470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47471       };
47472     }
47473   }
47474 }
47475
47476
47477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
47478   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47479   Dali::Vector< float >::SizeType arg2 ;
47480   Dali::Vector< float >::ItemType *arg3 = 0 ;
47481   Dali::Vector< float >::ItemType temp3 ;
47482
47483   arg1 = (Dali::Vector< float > *)jarg1;
47484   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47485   temp3 = (Dali::Vector< float >::ItemType)jarg3;
47486   arg3 = &temp3;
47487   {
47488     try {
47489       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
47490     } catch (std::out_of_range& e) {
47491       {
47492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47493       };
47494     } catch (std::exception& e) {
47495       {
47496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47497       };
47498     } catch (...) {
47499       {
47500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47501       };
47502     }
47503   }
47504 }
47505
47506
47507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
47508   void * jresult ;
47509   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47510   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47511   Dali::Vector< float >::Iterator result;
47512
47513   arg1 = (Dali::Vector< float > *)jarg1;
47514   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47515   {
47516     try {
47517       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
47518     } catch (std::out_of_range& e) {
47519       {
47520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47521       };
47522     } catch (std::exception& e) {
47523       {
47524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47525       };
47526     } catch (...) {
47527       {
47528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47529       };
47530     }
47531   }
47532   jresult = (void *)result;
47533   return jresult;
47534 }
47535
47536
47537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
47538   void * jresult ;
47539   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47540   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47541   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
47542   Dali::Vector< float >::Iterator result;
47543
47544   arg1 = (Dali::Vector< float > *)jarg1;
47545   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47546   arg3 = (Dali::Vector< float >::Iterator)jarg3;
47547   {
47548     try {
47549       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
47550     } catch (std::out_of_range& e) {
47551       {
47552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47553       };
47554     } catch (std::exception& e) {
47555       {
47556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47557       };
47558     } catch (...) {
47559       {
47560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47561       };
47562     }
47563   }
47564   jresult = (void *)result;
47565   return jresult;
47566 }
47567
47568
47569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
47570   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47571   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47572
47573   arg1 = (Dali::Vector< float > *)jarg1;
47574   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47575   {
47576     try {
47577       (arg1)->Remove(arg2);
47578     } catch (std::out_of_range& e) {
47579       {
47580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47581       };
47582     } catch (std::exception& e) {
47583       {
47584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47585       };
47586     } catch (...) {
47587       {
47588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47589       };
47590     }
47591   }
47592 }
47593
47594
47595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
47596   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47597   Dali::Vector< float > *arg2 = 0 ;
47598
47599   arg1 = (Dali::Vector< float > *)jarg1;
47600   arg2 = (Dali::Vector< float > *)jarg2;
47601   if (!arg2) {
47602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
47603     return ;
47604   }
47605   {
47606     try {
47607       (arg1)->Swap(*arg2);
47608     } catch (std::out_of_range& e) {
47609       {
47610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47611       };
47612     } catch (std::exception& e) {
47613       {
47614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47615       };
47616     } catch (...) {
47617       {
47618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47619       };
47620     }
47621   }
47622 }
47623
47624
47625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
47626   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47627
47628   arg1 = (Dali::Vector< float > *)jarg1;
47629   {
47630     try {
47631       (arg1)->Clear();
47632     } catch (std::out_of_range& e) {
47633       {
47634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47635       };
47636     } catch (std::exception& e) {
47637       {
47638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47639       };
47640     } catch (...) {
47641       {
47642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47643       };
47644     }
47645   }
47646 }
47647
47648
47649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
47650   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47651
47652   arg1 = (Dali::Vector< float > *)jarg1;
47653   {
47654     try {
47655       (arg1)->Release();
47656     } catch (std::out_of_range& e) {
47657       {
47658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47659       };
47660     } catch (std::exception& e) {
47661       {
47662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47663       };
47664     } catch (...) {
47665       {
47666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47667       };
47668     }
47669   }
47670 }
47671
47672
47673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
47674   int jresult ;
47675   int result;
47676
47677   result = (int)Dali::Vector< unsigned char >::BaseType;
47678   jresult = (int)result;
47679   return jresult;
47680 }
47681
47682
47683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
47684   void * jresult ;
47685   Dali::Vector< unsigned char > *result = 0 ;
47686
47687   {
47688     try {
47689       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
47690     } catch (std::out_of_range& e) {
47691       {
47692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47693       };
47694     } catch (std::exception& e) {
47695       {
47696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47697       };
47698     } catch (...) {
47699       {
47700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47701       };
47702     }
47703   }
47704   jresult = (void *)result;
47705   return jresult;
47706 }
47707
47708
47709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
47710   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47711
47712   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47713   {
47714     try {
47715       delete arg1;
47716     } catch (std::out_of_range& e) {
47717       {
47718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47719       };
47720     } catch (std::exception& e) {
47721       {
47722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47723       };
47724     } catch (...) {
47725       {
47726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47727       };
47728     }
47729   }
47730 }
47731
47732
47733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
47734   void * jresult ;
47735   Dali::Vector< unsigned char > *arg1 = 0 ;
47736   Dali::Vector< unsigned char > *result = 0 ;
47737
47738   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47739   if (!arg1) {
47740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47741     return 0;
47742   }
47743   {
47744     try {
47745       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
47746     } catch (std::out_of_range& e) {
47747       {
47748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47749       };
47750     } catch (std::exception& e) {
47751       {
47752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47753       };
47754     } catch (...) {
47755       {
47756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47757       };
47758     }
47759   }
47760   jresult = (void *)result;
47761   return jresult;
47762 }
47763
47764
47765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
47766   void * jresult ;
47767   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47768   Dali::Vector< unsigned char > *arg2 = 0 ;
47769   Dali::Vector< unsigned char > *result = 0 ;
47770
47771   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47772   arg2 = (Dali::Vector< unsigned char > *)jarg2;
47773   if (!arg2) {
47774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47775     return 0;
47776   }
47777   {
47778     try {
47779       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
47780     } catch (std::out_of_range& e) {
47781       {
47782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47783       };
47784     } catch (std::exception& e) {
47785       {
47786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47787       };
47788     } catch (...) {
47789       {
47790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47791       };
47792     }
47793   }
47794   jresult = (void *)result;
47795   return jresult;
47796 }
47797
47798
47799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
47800   void * jresult ;
47801   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47802   Dali::Vector< unsigned char >::Iterator result;
47803
47804   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47805   {
47806     try {
47807       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
47808     } catch (std::out_of_range& e) {
47809       {
47810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47811       };
47812     } catch (std::exception& e) {
47813       {
47814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47815       };
47816     } catch (...) {
47817       {
47818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47819       };
47820     }
47821   }
47822   jresult = (void *)result;
47823   return jresult;
47824 }
47825
47826
47827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
47828   void * jresult ;
47829   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47830   Dali::Vector< unsigned char >::Iterator result;
47831
47832   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47833   {
47834     try {
47835       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
47836     } catch (std::out_of_range& e) {
47837       {
47838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47839       };
47840     } catch (std::exception& e) {
47841       {
47842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47843       };
47844     } catch (...) {
47845       {
47846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47847       };
47848     }
47849   }
47850   jresult = (void *)result;
47851   return jresult;
47852 }
47853
47854
47855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47856   void * jresult ;
47857   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47858   Dali::Vector< unsigned char >::SizeType arg2 ;
47859   Dali::Vector< unsigned char >::ItemType *result = 0 ;
47860
47861   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47862   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47863   {
47864     try {
47865       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
47866     } catch (std::out_of_range& e) {
47867       {
47868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47869       };
47870     } catch (std::exception& e) {
47871       {
47872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47873       };
47874     } catch (...) {
47875       {
47876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47877       };
47878     }
47879   }
47880   jresult = (void *)result;
47881   return jresult;
47882 }
47883
47884
47885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
47886   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47887   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
47888   Dali::Vector< unsigned char >::ItemType temp2 ;
47889
47890   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47891   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
47892   arg2 = &temp2;
47893   {
47894     try {
47895       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
47896     } catch (std::out_of_range& e) {
47897       {
47898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47899       };
47900     } catch (std::exception& e) {
47901       {
47902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47903       };
47904     } catch (...) {
47905       {
47906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47907       };
47908     }
47909   }
47910 }
47911
47912
47913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
47914   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47915   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47916   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
47917   Dali::Vector< unsigned char >::ItemType temp3 ;
47918
47919   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47920   arg2 = jarg2;
47921   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
47922   arg3 = &temp3;
47923   {
47924     try {
47925       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
47926     } catch (std::out_of_range& e) {
47927       {
47928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47929       };
47930     } catch (std::exception& e) {
47931       {
47932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47933       };
47934     } catch (...) {
47935       {
47936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47937       };
47938     }
47939   }
47940
47941
47942 }
47943
47944
47945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
47946   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47947   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47948   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47949   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47950
47951   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47952   arg2 = jarg2;
47953   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
47954   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
47955   {
47956     try {
47957       (arg1)->Insert(arg2,arg3,arg4);
47958     } catch (std::out_of_range& e) {
47959       {
47960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47961       };
47962     } catch (std::exception& e) {
47963       {
47964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47965       };
47966     } catch (...) {
47967       {
47968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47969       };
47970     }
47971   }
47972
47973
47974 }
47975
47976
47977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
47978   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47979   Dali::Vector< unsigned char >::SizeType arg2 ;
47980
47981   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47982   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47983   {
47984     try {
47985       (arg1)->Reserve(arg2);
47986     } catch (std::out_of_range& e) {
47987       {
47988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47989       };
47990     } catch (std::exception& e) {
47991       {
47992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47993       };
47994     } catch (...) {
47995       {
47996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47997       };
47998     }
47999   }
48000 }
48001
48002
48003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48004   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48005   Dali::Vector< unsigned char >::SizeType arg2 ;
48006
48007   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48008   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
48009   {
48010     try {
48011       (arg1)->Resize(arg2);
48012     } catch (std::out_of_range& e) {
48013       {
48014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48015       };
48016     } catch (std::exception& e) {
48017       {
48018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48019       };
48020     } catch (...) {
48021       {
48022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48023       };
48024     }
48025   }
48026 }
48027
48028
48029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
48030   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48031   Dali::Vector< unsigned char >::SizeType arg2 ;
48032   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
48033   Dali::Vector< unsigned char >::ItemType temp3 ;
48034
48035   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48036   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
48037   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
48038   arg3 = &temp3;
48039   {
48040     try {
48041       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
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 void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
48060   void * jresult ;
48061   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48062   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48063   Dali::Vector< unsigned char >::Iterator result;
48064
48065   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48066   arg2 = jarg2;
48067   {
48068     try {
48069       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
48070     } catch (std::out_of_range& e) {
48071       {
48072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48073       };
48074     } catch (std::exception& e) {
48075       {
48076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48077       };
48078     } catch (...) {
48079       {
48080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48081       };
48082     }
48083   }
48084   jresult = (void *)result;
48085
48086
48087   return jresult;
48088 }
48089
48090
48091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
48092   void * jresult ;
48093   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48094   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48095   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48096   Dali::Vector< unsigned char >::Iterator result;
48097
48098   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48099   arg2 = jarg2;
48100   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
48101   {
48102     try {
48103       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
48104     } catch (std::out_of_range& e) {
48105       {
48106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48107       };
48108     } catch (std::exception& e) {
48109       {
48110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48111       };
48112     } catch (...) {
48113       {
48114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48115       };
48116     }
48117   }
48118   jresult = (void *)result;
48119
48120
48121   return jresult;
48122 }
48123
48124
48125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
48126   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48127   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48128
48129   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48130   arg2 = jarg2;
48131   {
48132     try {
48133       (arg1)->Remove(arg2);
48134     } catch (std::out_of_range& e) {
48135       {
48136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48137       };
48138     } catch (std::exception& e) {
48139       {
48140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48141       };
48142     } catch (...) {
48143       {
48144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48145       };
48146     }
48147   }
48148
48149
48150 }
48151
48152
48153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
48154   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48155   Dali::Vector< unsigned char > *arg2 = 0 ;
48156
48157   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48158   arg2 = (Dali::Vector< unsigned char > *)jarg2;
48159   if (!arg2) {
48160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
48161     return ;
48162   }
48163   {
48164     try {
48165       (arg1)->Swap(*arg2);
48166     } catch (std::out_of_range& e) {
48167       {
48168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48169       };
48170     } catch (std::exception& e) {
48171       {
48172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48173       };
48174     } catch (...) {
48175       {
48176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48177       };
48178     }
48179   }
48180 }
48181
48182
48183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
48184   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48185
48186   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48187   {
48188     try {
48189       (arg1)->Clear();
48190     } catch (std::out_of_range& e) {
48191       {
48192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48193       };
48194     } catch (std::exception& e) {
48195       {
48196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48197       };
48198     } catch (...) {
48199       {
48200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48201       };
48202     }
48203   }
48204 }
48205
48206
48207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
48208   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48209
48210   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48211   {
48212     try {
48213       (arg1)->Release();
48214     } catch (std::out_of_range& e) {
48215       {
48216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48217       };
48218     } catch (std::exception& e) {
48219       {
48220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48221       };
48222     } catch (...) {
48223       {
48224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48225       };
48226     }
48227   }
48228 }
48229
48230
48231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
48232   int jresult ;
48233   int result;
48234
48235   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
48236   jresult = (int)result;
48237   return jresult;
48238 }
48239
48240
48241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
48242   void * jresult ;
48243   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48244
48245   {
48246     try {
48247       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
48248     } catch (std::out_of_range& e) {
48249       {
48250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48251       };
48252     } catch (std::exception& e) {
48253       {
48254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48255       };
48256     } catch (...) {
48257       {
48258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48259       };
48260     }
48261   }
48262   jresult = (void *)result;
48263   return jresult;
48264 }
48265
48266
48267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
48268   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48269
48270   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48271   {
48272     try {
48273       delete arg1;
48274     } catch (std::out_of_range& e) {
48275       {
48276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48277       };
48278     } catch (std::exception& e) {
48279       {
48280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48281       };
48282     } catch (...) {
48283       {
48284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48285       };
48286     }
48287   }
48288 }
48289
48290
48291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
48292   void * jresult ;
48293   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
48294   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48295
48296   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48297   if (!arg1) {
48298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
48299     return 0;
48300   }
48301   {
48302     try {
48303       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
48304     } catch (std::out_of_range& e) {
48305       {
48306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48307       };
48308     } catch (std::exception& e) {
48309       {
48310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48311       };
48312     } catch (...) {
48313       {
48314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48315       };
48316     }
48317   }
48318   jresult = (void *)result;
48319   return jresult;
48320 }
48321
48322
48323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
48324   void * jresult ;
48325   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48326   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
48327   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48328
48329   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48330   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
48331   if (!arg2) {
48332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
48333     return 0;
48334   }
48335   {
48336     try {
48337       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
48338     } catch (std::out_of_range& e) {
48339       {
48340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48341       };
48342     } catch (std::exception& e) {
48343       {
48344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48345       };
48346     } catch (...) {
48347       {
48348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48349       };
48350     }
48351   }
48352   jresult = (void *)result;
48353   return jresult;
48354 }
48355
48356
48357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
48358   void * jresult ;
48359   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48360   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48361
48362   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48363   {
48364     try {
48365       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
48366     } catch (std::out_of_range& e) {
48367       {
48368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48369       };
48370     } catch (std::exception& e) {
48371       {
48372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48373       };
48374     } catch (...) {
48375       {
48376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48377       };
48378     }
48379   }
48380   jresult = (void *)result;
48381   return jresult;
48382 }
48383
48384
48385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
48386   void * jresult ;
48387   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48388   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48389
48390   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48391   {
48392     try {
48393       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
48394     } catch (std::out_of_range& e) {
48395       {
48396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48397       };
48398     } catch (std::exception& e) {
48399       {
48400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48401       };
48402     } catch (...) {
48403       {
48404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48405       };
48406     }
48407   }
48408   jresult = (void *)result;
48409   return jresult;
48410 }
48411
48412
48413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48414   void * jresult ;
48415   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48416   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48417   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
48418
48419   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48420   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48421   {
48422     try {
48423       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
48424     } catch (std::out_of_range& e) {
48425       {
48426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48427       };
48428     } catch (std::exception& e) {
48429       {
48430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48431       };
48432     } catch (...) {
48433       {
48434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48435       };
48436     }
48437   }
48438   jresult = (void *)result;
48439   return jresult;
48440 }
48441
48442
48443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
48444   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48445   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
48446
48447   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48448   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
48449   if (!arg2) {
48450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48451     return ;
48452   }
48453   {
48454     try {
48455       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
48456     } catch (std::out_of_range& e) {
48457       {
48458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48459       };
48460     } catch (std::exception& e) {
48461       {
48462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48463       };
48464     } catch (...) {
48465       {
48466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48467       };
48468     }
48469   }
48470 }
48471
48472
48473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
48474   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48475   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48476   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
48477
48478   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48479   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48480   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
48481   if (!arg3) {
48482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48483     return ;
48484   }
48485   {
48486     try {
48487       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
48488     } catch (std::out_of_range& e) {
48489       {
48490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48491       };
48492     } catch (std::exception& e) {
48493       {
48494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48495       };
48496     } catch (...) {
48497       {
48498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48499       };
48500     }
48501   }
48502 }
48503
48504
48505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48506   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48507   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48508   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48509   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48510
48511   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48512   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48513   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
48514   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
48515   {
48516     try {
48517       (arg1)->Insert(arg2,arg3,arg4);
48518     } catch (std::out_of_range& e) {
48519       {
48520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48521       };
48522     } catch (std::exception& e) {
48523       {
48524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48525       };
48526     } catch (...) {
48527       {
48528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48529       };
48530     }
48531   }
48532 }
48533
48534
48535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
48536   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48537   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48538
48539   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48540   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48541   {
48542     try {
48543       (arg1)->Reserve(arg2);
48544     } catch (std::out_of_range& e) {
48545       {
48546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48547       };
48548     } catch (std::exception& e) {
48549       {
48550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48551       };
48552     } catch (...) {
48553       {
48554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48555       };
48556     }
48557   }
48558 }
48559
48560
48561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48562   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48563   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48564
48565   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48566   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48567   {
48568     try {
48569       (arg1)->Resize(arg2);
48570     } catch (std::out_of_range& e) {
48571       {
48572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48573       };
48574     } catch (std::exception& e) {
48575       {
48576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48577       };
48578     } catch (...) {
48579       {
48580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48581       };
48582     }
48583   }
48584 }
48585
48586
48587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
48588   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48589   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48590   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
48591
48592   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48593   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48594   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
48595   if (!arg3) {
48596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48597     return ;
48598   }
48599   {
48600     try {
48601       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
48602     } catch (std::out_of_range& e) {
48603       {
48604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48605       };
48606     } catch (std::exception& e) {
48607       {
48608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48609       };
48610     } catch (...) {
48611       {
48612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48613       };
48614     }
48615   }
48616 }
48617
48618
48619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
48620   void * jresult ;
48621   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48622   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48623   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48624
48625   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48626   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48627   {
48628     try {
48629       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
48630     } catch (std::out_of_range& e) {
48631       {
48632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48633       };
48634     } catch (std::exception& e) {
48635       {
48636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48637       };
48638     } catch (...) {
48639       {
48640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48641       };
48642     }
48643   }
48644   jresult = (void *)result;
48645   return jresult;
48646 }
48647
48648
48649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48650   void * jresult ;
48651   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48652   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48653   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48654   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48655
48656   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48657   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48658   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
48659   {
48660     try {
48661       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
48662     } catch (std::out_of_range& e) {
48663       {
48664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48665       };
48666     } catch (std::exception& e) {
48667       {
48668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48669       };
48670     } catch (...) {
48671       {
48672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48673       };
48674     }
48675   }
48676   jresult = (void *)result;
48677   return jresult;
48678 }
48679
48680
48681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
48682   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48683   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48684
48685   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48686   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48687   {
48688     try {
48689       (arg1)->Remove(arg2);
48690     } catch (std::out_of_range& e) {
48691       {
48692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48693       };
48694     } catch (std::exception& e) {
48695       {
48696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48697       };
48698     } catch (...) {
48699       {
48700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48701       };
48702     }
48703   }
48704 }
48705
48706
48707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
48708   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48709   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
48710
48711   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48712   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
48713   if (!arg2) {
48714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
48715     return ;
48716   }
48717   {
48718     try {
48719       (arg1)->Swap(*arg2);
48720     } catch (std::out_of_range& e) {
48721       {
48722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48723       };
48724     } catch (std::exception& e) {
48725       {
48726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48727       };
48728     } catch (...) {
48729       {
48730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48731       };
48732     }
48733   }
48734 }
48735
48736
48737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
48738   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48739
48740   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48741   {
48742     try {
48743       (arg1)->Clear();
48744     } catch (std::out_of_range& e) {
48745       {
48746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48747       };
48748     } catch (std::exception& e) {
48749       {
48750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48751       };
48752     } catch (...) {
48753       {
48754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48755       };
48756     }
48757   }
48758 }
48759
48760
48761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
48762   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48763
48764   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48765   {
48766     try {
48767       (arg1)->Release();
48768     } catch (std::out_of_range& e) {
48769       {
48770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48771       };
48772     } catch (std::exception& e) {
48773       {
48774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48775       };
48776     } catch (...) {
48777       {
48778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48779       };
48780     }
48781   }
48782 }
48783
48784
48785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
48786   void * jresult ;
48787   Dali::Signal< void () > *result = 0 ;
48788
48789   {
48790     try {
48791       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
48792     } catch (std::out_of_range& e) {
48793       {
48794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48795       };
48796     } catch (std::exception& e) {
48797       {
48798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48799       };
48800     } catch (...) {
48801       {
48802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48803       };
48804     }
48805   }
48806   jresult = (void *)result;
48807   return jresult;
48808 }
48809
48810
48811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
48812   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48813
48814   arg1 = (Dali::Signal< void () > *)jarg1;
48815   {
48816     try {
48817       delete arg1;
48818     } catch (std::out_of_range& e) {
48819       {
48820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48821       };
48822     } catch (std::exception& e) {
48823       {
48824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48825       };
48826     } catch (...) {
48827       {
48828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48829       };
48830     }
48831   }
48832 }
48833
48834
48835 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
48836   unsigned int jresult ;
48837   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48838   bool result;
48839
48840   arg1 = (Dali::Signal< void () > *)jarg1;
48841   {
48842     try {
48843       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
48844     } catch (std::out_of_range& e) {
48845       {
48846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48847       };
48848     } catch (std::exception& e) {
48849       {
48850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48851       };
48852     } catch (...) {
48853       {
48854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48855       };
48856     }
48857   }
48858   jresult = result;
48859   return jresult;
48860 }
48861
48862
48863 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
48864   unsigned long jresult ;
48865   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48866   std::size_t result;
48867
48868   arg1 = (Dali::Signal< void () > *)jarg1;
48869   {
48870     try {
48871       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
48872     } catch (std::out_of_range& e) {
48873       {
48874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48875       };
48876     } catch (std::exception& e) {
48877       {
48878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48879       };
48880     } catch (...) {
48881       {
48882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48883       };
48884     }
48885   }
48886   jresult = (unsigned long)result;
48887   return jresult;
48888 }
48889
48890
48891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
48892   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48893   void (*arg2)() = (void (*)()) 0 ;
48894
48895   arg1 = (Dali::Signal< void () > *)jarg1;
48896   arg2 = (void (*)())jarg2;
48897   {
48898     try {
48899       (arg1)->Connect(arg2);
48900     } catch (std::out_of_range& e) {
48901       {
48902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48903       };
48904     } catch (std::exception& e) {
48905       {
48906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48907       };
48908     } catch (...) {
48909       {
48910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48911       };
48912     }
48913   }
48914 }
48915
48916
48917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
48918   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48919   void (*arg2)() = (void (*)()) 0 ;
48920
48921   arg1 = (Dali::Signal< void () > *)jarg1;
48922   arg2 = (void (*)())jarg2;
48923   {
48924     try {
48925       (arg1)->Disconnect(arg2);
48926     } catch (std::out_of_range& e) {
48927       {
48928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48929       };
48930     } catch (std::exception& e) {
48931       {
48932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48933       };
48934     } catch (...) {
48935       {
48936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48937       };
48938     }
48939   }
48940 }
48941
48942
48943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
48944   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48945   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
48946   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
48947
48948   arg1 = (Dali::Signal< void () > *)jarg1;
48949   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
48950   arg3 = (Dali::FunctorDelegate *)jarg3;
48951   {
48952     try {
48953       (arg1)->Connect(arg2,arg3);
48954     } catch (std::out_of_range& e) {
48955       {
48956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48957       };
48958     } catch (std::exception& e) {
48959       {
48960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48961       };
48962     } catch (...) {
48963       {
48964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48965       };
48966     }
48967   }
48968 }
48969
48970
48971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
48972   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48973
48974   arg1 = (Dali::Signal< void () > *)jarg1;
48975   {
48976     try {
48977       (arg1)->Emit();
48978     } catch (std::out_of_range& e) {
48979       {
48980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48981       };
48982     } catch (std::exception& e) {
48983       {
48984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48985       };
48986     } catch (...) {
48987       {
48988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48989       };
48990     }
48991   }
48992 }
48993
48994
48995 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
48996   unsigned int jresult ;
48997   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48998   bool result;
48999
49000   arg1 = (Dali::Signal< void (float) > *)jarg1;
49001   {
49002     try {
49003       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
49004     } catch (std::out_of_range& e) {
49005       {
49006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49007       };
49008     } catch (std::exception& e) {
49009       {
49010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49011       };
49012     } catch (...) {
49013       {
49014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49015       };
49016     }
49017   }
49018   jresult = result;
49019   return jresult;
49020 }
49021
49022
49023 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
49024   unsigned long jresult ;
49025   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49026   std::size_t result;
49027
49028   arg1 = (Dali::Signal< void (float) > *)jarg1;
49029   {
49030     try {
49031       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
49032     } catch (std::out_of_range& e) {
49033       {
49034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49035       };
49036     } catch (std::exception& e) {
49037       {
49038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49039       };
49040     } catch (...) {
49041       {
49042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49043       };
49044     }
49045   }
49046   jresult = (unsigned long)result;
49047   return jresult;
49048 }
49049
49050
49051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
49052   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49053   void (*arg2)(float) = (void (*)(float)) 0 ;
49054
49055   arg1 = (Dali::Signal< void (float) > *)jarg1;
49056   arg2 = (void (*)(float))jarg2;
49057   {
49058     try {
49059       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
49060     } catch (std::out_of_range& e) {
49061       {
49062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49063       };
49064     } catch (std::exception& e) {
49065       {
49066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49067       };
49068     } catch (...) {
49069       {
49070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49071       };
49072     }
49073   }
49074 }
49075
49076
49077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
49078   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49079   void (*arg2)(float) = (void (*)(float)) 0 ;
49080
49081   arg1 = (Dali::Signal< void (float) > *)jarg1;
49082   arg2 = (void (*)(float))jarg2;
49083   {
49084     try {
49085       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
49086     } catch (std::out_of_range& e) {
49087       {
49088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49089       };
49090     } catch (std::exception& e) {
49091       {
49092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49093       };
49094     } catch (...) {
49095       {
49096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49097       };
49098     }
49099   }
49100 }
49101
49102
49103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
49104   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49105   float arg2 ;
49106
49107   arg1 = (Dali::Signal< void (float) > *)jarg1;
49108   arg2 = (float)jarg2;
49109   {
49110     try {
49111       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
49112     } catch (std::out_of_range& e) {
49113       {
49114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49115       };
49116     } catch (std::exception& e) {
49117       {
49118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49119       };
49120     } catch (...) {
49121       {
49122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49123       };
49124     }
49125   }
49126 }
49127
49128
49129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
49130   void * jresult ;
49131   Dali::Signal< void (float) > *result = 0 ;
49132
49133   {
49134     try {
49135       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
49136     } catch (std::out_of_range& e) {
49137       {
49138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49139       };
49140     } catch (std::exception& e) {
49141       {
49142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49143       };
49144     } catch (...) {
49145       {
49146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49147       };
49148     }
49149   }
49150   jresult = (void *)result;
49151   return jresult;
49152 }
49153
49154
49155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
49156   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49157
49158   arg1 = (Dali::Signal< void (float) > *)jarg1;
49159   {
49160     try {
49161       delete arg1;
49162     } catch (std::out_of_range& e) {
49163       {
49164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49165       };
49166     } catch (std::exception& e) {
49167       {
49168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49169       };
49170     } catch (...) {
49171       {
49172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49173       };
49174     }
49175   }
49176 }
49177
49178
49179 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
49180   unsigned int jresult ;
49181   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49182   bool result;
49183
49184   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49185   {
49186     try {
49187       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
49188     } catch (std::out_of_range& e) {
49189       {
49190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49191       };
49192     } catch (std::exception& e) {
49193       {
49194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49195       };
49196     } catch (...) {
49197       {
49198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49199       };
49200     }
49201   }
49202   jresult = result;
49203   return jresult;
49204 }
49205
49206
49207 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
49208   unsigned long jresult ;
49209   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49210   std::size_t result;
49211
49212   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49213   {
49214     try {
49215       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
49216     } catch (std::out_of_range& e) {
49217       {
49218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49219       };
49220     } catch (std::exception& e) {
49221       {
49222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49223       };
49224     } catch (...) {
49225       {
49226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49227       };
49228     }
49229   }
49230   jresult = (unsigned long)result;
49231   return jresult;
49232 }
49233
49234
49235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
49236   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49237   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
49238
49239   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49240   arg2 = (void (*)(Dali::BaseHandle))jarg2;
49241   {
49242     try {
49243       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
49244     } catch (std::out_of_range& e) {
49245       {
49246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49247       };
49248     } catch (std::exception& e) {
49249       {
49250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49251       };
49252     } catch (...) {
49253       {
49254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49255       };
49256     }
49257   }
49258 }
49259
49260
49261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
49262   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49263   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
49264
49265   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49266   arg2 = (void (*)(Dali::BaseHandle))jarg2;
49267   {
49268     try {
49269       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
49270     } catch (std::out_of_range& e) {
49271       {
49272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49273       };
49274     } catch (std::exception& e) {
49275       {
49276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49277       };
49278     } catch (...) {
49279       {
49280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49281       };
49282     }
49283   }
49284 }
49285
49286
49287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
49288   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49289   Dali::BaseHandle arg2 ;
49290   Dali::BaseHandle *argp2 ;
49291
49292   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49293   argp2 = (Dali::BaseHandle *)jarg2;
49294   if (!argp2) {
49295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49296     return ;
49297   }
49298   arg2 = *argp2;
49299   {
49300     try {
49301       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
49302     } catch (std::out_of_range& e) {
49303       {
49304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49305       };
49306     } catch (std::exception& e) {
49307       {
49308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49309       };
49310     } catch (...) {
49311       {
49312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49313       };
49314     }
49315   }
49316 }
49317
49318
49319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
49320   void * jresult ;
49321   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
49322
49323   {
49324     try {
49325       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
49326     } catch (std::out_of_range& e) {
49327       {
49328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49329       };
49330     } catch (std::exception& e) {
49331       {
49332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49333       };
49334     } catch (...) {
49335       {
49336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49337       };
49338     }
49339   }
49340   jresult = (void *)result;
49341   return jresult;
49342 }
49343
49344
49345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
49346   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49347
49348   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49349   {
49350     try {
49351       delete arg1;
49352     } catch (std::out_of_range& e) {
49353       {
49354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49355       };
49356     } catch (std::exception& e) {
49357       {
49358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49359       };
49360     } catch (...) {
49361       {
49362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49363       };
49364     }
49365   }
49366 }
49367
49368
49369 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
49370   unsigned int jresult ;
49371   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49372   bool result;
49373
49374   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49375   {
49376     try {
49377       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
49378     } catch (std::out_of_range& e) {
49379       {
49380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49381       };
49382     } catch (std::exception& e) {
49383       {
49384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49385       };
49386     } catch (...) {
49387       {
49388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49389       };
49390     }
49391   }
49392   jresult = result;
49393   return jresult;
49394 }
49395
49396
49397 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
49398   unsigned long jresult ;
49399   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49400   std::size_t result;
49401
49402   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49403   {
49404     try {
49405       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
49406     } catch (std::out_of_range& e) {
49407       {
49408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49409       };
49410     } catch (std::exception& e) {
49411       {
49412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49413       };
49414     } catch (...) {
49415       {
49416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49417       };
49418     }
49419   }
49420   jresult = (unsigned long)result;
49421   return jresult;
49422 }
49423
49424
49425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
49426   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49427   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
49428
49429   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49430   arg2 = (void (*)(Dali::RefObject const *))jarg2;
49431   {
49432     try {
49433       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
49434     } catch (std::out_of_range& e) {
49435       {
49436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49437       };
49438     } catch (std::exception& e) {
49439       {
49440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49441       };
49442     } catch (...) {
49443       {
49444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49445       };
49446     }
49447   }
49448 }
49449
49450
49451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
49452   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49453   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
49454
49455   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49456   arg2 = (void (*)(Dali::RefObject const *))jarg2;
49457   {
49458     try {
49459       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
49460     } catch (std::out_of_range& e) {
49461       {
49462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49463       };
49464     } catch (std::exception& e) {
49465       {
49466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49467       };
49468     } catch (...) {
49469       {
49470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49471       };
49472     }
49473   }
49474 }
49475
49476
49477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
49478   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49479   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
49480
49481   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49482   arg2 = (Dali::RefObject *)jarg2;
49483   {
49484     try {
49485       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
49486     } catch (std::out_of_range& e) {
49487       {
49488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49489       };
49490     } catch (std::exception& e) {
49491       {
49492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49493       };
49494     } catch (...) {
49495       {
49496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49497       };
49498     }
49499   }
49500 }
49501
49502
49503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
49504   void * jresult ;
49505   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
49506
49507   {
49508     try {
49509       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
49510     } catch (std::out_of_range& e) {
49511       {
49512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49513       };
49514     } catch (std::exception& e) {
49515       {
49516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49517       };
49518     } catch (...) {
49519       {
49520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49521       };
49522     }
49523   }
49524   jresult = (void *)result;
49525   return jresult;
49526 }
49527
49528
49529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
49530   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49531
49532   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49533   {
49534     try {
49535       delete arg1;
49536     } catch (std::out_of_range& e) {
49537       {
49538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49539       };
49540     } catch (std::exception& e) {
49541       {
49542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49543       };
49544     } catch (...) {
49545       {
49546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49547       };
49548     }
49549   }
49550 }
49551
49552
49553 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
49554   unsigned int jresult ;
49555   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49556   bool result;
49557
49558   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49559   {
49560     try {
49561       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
49562     } catch (std::out_of_range& e) {
49563       {
49564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49565       };
49566     } catch (std::exception& e) {
49567       {
49568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49569       };
49570     } catch (...) {
49571       {
49572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49573       };
49574     }
49575   }
49576   jresult = result;
49577   return jresult;
49578 }
49579
49580
49581 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
49582   unsigned long jresult ;
49583   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49584   std::size_t result;
49585
49586   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49587   {
49588     try {
49589       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > 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 = (unsigned long)result;
49605   return jresult;
49606 }
49607
49608
49609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
49610   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49611   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49612
49613   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49614   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49615   {
49616     try {
49617       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
49618     } catch (std::out_of_range& e) {
49619       {
49620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49621       };
49622     } catch (std::exception& e) {
49623       {
49624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49625       };
49626     } catch (...) {
49627       {
49628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49629       };
49630     }
49631   }
49632 }
49633
49634
49635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
49636   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49637   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49638
49639   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49640   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49641   {
49642     try {
49643       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
49644     } catch (std::out_of_range& e) {
49645       {
49646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49647       };
49648     } catch (std::exception& e) {
49649       {
49650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49651       };
49652     } catch (...) {
49653       {
49654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49655       };
49656     }
49657   }
49658 }
49659
49660
49661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
49662   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49663   Dali::PropertyNotification *arg2 = 0 ;
49664
49665   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49666   arg2 = (Dali::PropertyNotification *)jarg2;
49667   if (!arg2) {
49668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
49669     return ;
49670   }
49671   {
49672     try {
49673       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
49674     } catch (std::out_of_range& e) {
49675       {
49676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49677       };
49678     } catch (std::exception& e) {
49679       {
49680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49681       };
49682     } catch (...) {
49683       {
49684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49685       };
49686     }
49687   }
49688 }
49689
49690
49691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
49692   void * jresult ;
49693   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
49694
49695   {
49696     try {
49697       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
49698     } catch (std::out_of_range& e) {
49699       {
49700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49701       };
49702     } catch (std::exception& e) {
49703       {
49704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49705       };
49706     } catch (...) {
49707       {
49708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49709       };
49710     }
49711   }
49712   jresult = (void *)result;
49713   return jresult;
49714 }
49715
49716
49717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
49718   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49719
49720   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49721   {
49722     try {
49723       delete arg1;
49724     } catch (std::out_of_range& e) {
49725       {
49726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49727       };
49728     } catch (std::exception& e) {
49729       {
49730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49731       };
49732     } catch (...) {
49733       {
49734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49735       };
49736     }
49737   }
49738 }
49739
49740
49741 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
49742   unsigned int jresult ;
49743   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49744   bool result;
49745
49746   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49747   {
49748     try {
49749       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
49750     } catch (std::out_of_range& e) {
49751       {
49752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49753       };
49754     } catch (std::exception& e) {
49755       {
49756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49757       };
49758     } catch (...) {
49759       {
49760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49761       };
49762     }
49763   }
49764   jresult = result;
49765   return jresult;
49766 }
49767
49768
49769 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
49770   unsigned long jresult ;
49771   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49772   std::size_t result;
49773
49774   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49775   {
49776     try {
49777       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
49778     } catch (std::out_of_range& e) {
49779       {
49780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49781       };
49782     } catch (std::exception& e) {
49783       {
49784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49785       };
49786     } catch (...) {
49787       {
49788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49789       };
49790     }
49791   }
49792   jresult = (unsigned long)result;
49793   return jresult;
49794 }
49795
49796
49797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
49798   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49799   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49800
49801   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49802   arg2 = (void (*)(Dali::Image))jarg2;
49803   {
49804     try {
49805       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
49806     } catch (std::out_of_range& e) {
49807       {
49808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49809       };
49810     } catch (std::exception& e) {
49811       {
49812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49813       };
49814     } catch (...) {
49815       {
49816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49817       };
49818     }
49819   }
49820 }
49821
49822
49823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
49824   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49825   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49826
49827   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49828   arg2 = (void (*)(Dali::Image))jarg2;
49829   {
49830     try {
49831       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
49832     } catch (std::out_of_range& e) {
49833       {
49834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49835       };
49836     } catch (std::exception& e) {
49837       {
49838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49839       };
49840     } catch (...) {
49841       {
49842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49843       };
49844     }
49845   }
49846 }
49847
49848
49849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
49850   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49851   Dali::Image arg2 ;
49852   Dali::Image *argp2 ;
49853
49854   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49855   argp2 = (Dali::Image *)jarg2;
49856   if (!argp2) {
49857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
49858     return ;
49859   }
49860   arg2 = *argp2;
49861   {
49862     try {
49863       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
49864     } catch (std::out_of_range& e) {
49865       {
49866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49867       };
49868     } catch (std::exception& e) {
49869       {
49870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49871       };
49872     } catch (...) {
49873       {
49874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49875       };
49876     }
49877   }
49878 }
49879
49880
49881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
49882   void * jresult ;
49883   Dali::Signal< void (Dali::Image) > *result = 0 ;
49884
49885   {
49886     try {
49887       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
49888     } catch (std::out_of_range& e) {
49889       {
49890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49891       };
49892     } catch (std::exception& e) {
49893       {
49894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49895       };
49896     } catch (...) {
49897       {
49898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49899       };
49900     }
49901   }
49902   jresult = (void *)result;
49903   return jresult;
49904 }
49905
49906
49907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
49908   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49909
49910   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49911   {
49912     try {
49913       delete arg1;
49914     } catch (std::out_of_range& e) {
49915       {
49916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49917       };
49918     } catch (std::exception& e) {
49919       {
49920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49921       };
49922     } catch (...) {
49923       {
49924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49925       };
49926     }
49927   }
49928 }
49929
49930
49931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
49932   void * jresult ;
49933   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
49934
49935   {
49936     try {
49937       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
49938     } catch (std::out_of_range& e) {
49939       {
49940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49941       };
49942     } catch (std::exception& e) {
49943       {
49944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49945       };
49946     } catch (...) {
49947       {
49948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49949       };
49950     }
49951   }
49952   jresult = (void *)result;
49953   return jresult;
49954 }
49955
49956
49957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
49958   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
49959
49960   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
49961   {
49962     try {
49963       delete arg1;
49964     } catch (std::out_of_range& e) {
49965       {
49966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49967       };
49968     } catch (std::exception& e) {
49969       {
49970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49971       };
49972     } catch (...) {
49973       {
49974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49975       };
49976     }
49977   }
49978 }
49979
49980
49981 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
49982   unsigned int jresult ;
49983   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49984   bool result;
49985
49986   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49987   {
49988     try {
49989       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);
49990     } catch (std::out_of_range& e) {
49991       {
49992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49993       };
49994     } catch (std::exception& e) {
49995       {
49996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49997       };
49998     } catch (...) {
49999       {
50000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50001       };
50002     }
50003   }
50004   jresult = result;
50005   return jresult;
50006 }
50007
50008
50009 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
50010   unsigned long jresult ;
50011   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50012   std::size_t result;
50013
50014   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50015   {
50016     try {
50017       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);
50018     } catch (std::out_of_range& e) {
50019       {
50020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50021       };
50022     } catch (std::exception& e) {
50023       {
50024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50025       };
50026     } catch (...) {
50027       {
50028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50029       };
50030     }
50031   }
50032   jresult = (unsigned long)result;
50033   return jresult;
50034 }
50035
50036
50037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
50038   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50039   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
50040
50041   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50042   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
50043   {
50044     try {
50045       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50046     } catch (std::out_of_range& e) {
50047       {
50048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50049       };
50050     } catch (std::exception& e) {
50051       {
50052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50053       };
50054     } catch (...) {
50055       {
50056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50057       };
50058     }
50059   }
50060 }
50061
50062
50063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
50064   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50065   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
50066
50067   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50068   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
50069   {
50070     try {
50071       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50072     } catch (std::out_of_range& e) {
50073       {
50074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50075       };
50076     } catch (std::exception& e) {
50077       {
50078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50079       };
50080     } catch (...) {
50081       {
50082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50083       };
50084     }
50085   }
50086 }
50087
50088
50089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50090   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50091   Dali::Actor arg2 ;
50092   Dali::LongPressGesture *arg3 = 0 ;
50093   Dali::Actor *argp2 ;
50094
50095   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50096   argp2 = (Dali::Actor *)jarg2;
50097   if (!argp2) {
50098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50099     return ;
50100   }
50101   arg2 = *argp2;
50102   arg3 = (Dali::LongPressGesture *)jarg3;
50103   if (!arg3) {
50104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
50105     return ;
50106   }
50107   {
50108     try {
50109       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
50110     } catch (std::out_of_range& e) {
50111       {
50112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50113       };
50114     } catch (std::exception& e) {
50115       {
50116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50117       };
50118     } catch (...) {
50119       {
50120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50121       };
50122     }
50123   }
50124 }
50125
50126
50127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
50128   void * jresult ;
50129   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
50130
50131   {
50132     try {
50133       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
50134     } catch (std::out_of_range& e) {
50135       {
50136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50137       };
50138     } catch (std::exception& e) {
50139       {
50140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50141       };
50142     } catch (...) {
50143       {
50144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50145       };
50146     }
50147   }
50148   jresult = (void *)result;
50149   return jresult;
50150 }
50151
50152
50153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
50154   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50155
50156   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50157   {
50158     try {
50159       delete arg1;
50160     } catch (std::out_of_range& e) {
50161       {
50162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50163       };
50164     } catch (std::exception& e) {
50165       {
50166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50167       };
50168     } catch (...) {
50169       {
50170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50171       };
50172     }
50173   }
50174 }
50175
50176
50177 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
50178   unsigned int jresult ;
50179   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50180   bool result;
50181
50182   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50183   {
50184     try {
50185       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);
50186     } catch (std::out_of_range& e) {
50187       {
50188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50189       };
50190     } catch (std::exception& e) {
50191       {
50192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50193       };
50194     } catch (...) {
50195       {
50196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50197       };
50198     }
50199   }
50200   jresult = result;
50201   return jresult;
50202 }
50203
50204
50205 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
50206   unsigned long jresult ;
50207   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50208   std::size_t result;
50209
50210   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50211   {
50212     try {
50213       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);
50214     } catch (std::out_of_range& e) {
50215       {
50216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50217       };
50218     } catch (std::exception& e) {
50219       {
50220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50221       };
50222     } catch (...) {
50223       {
50224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50225       };
50226     }
50227   }
50228   jresult = (unsigned long)result;
50229   return jresult;
50230 }
50231
50232
50233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
50234   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50235   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
50236
50237   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50238   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
50239   {
50240     try {
50241       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50242     } catch (std::out_of_range& e) {
50243       {
50244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50245       };
50246     } catch (std::exception& e) {
50247       {
50248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50249       };
50250     } catch (...) {
50251       {
50252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50253       };
50254     }
50255   }
50256 }
50257
50258
50259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
50260   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50261   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
50262
50263   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50264   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
50265   {
50266     try {
50267       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50268     } catch (std::out_of_range& e) {
50269       {
50270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50271       };
50272     } catch (std::exception& e) {
50273       {
50274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50275       };
50276     } catch (...) {
50277       {
50278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50279       };
50280     }
50281   }
50282 }
50283
50284
50285 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50286   unsigned int jresult ;
50287   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50288   Dali::Actor arg2 ;
50289   Dali::TouchData *arg3 = 0 ;
50290   Dali::Actor *argp2 ;
50291   bool result;
50292
50293   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50294   argp2 = (Dali::Actor *)jarg2;
50295   if (!argp2) {
50296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50297     return 0;
50298   }
50299   arg2 = *argp2;
50300   arg3 = (Dali::TouchData *)jarg3;
50301   if (!arg3) {
50302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
50303     return 0;
50304   }
50305   {
50306     try {
50307       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
50308     } catch (std::out_of_range& e) {
50309       {
50310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50311       };
50312     } catch (std::exception& e) {
50313       {
50314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50315       };
50316     } catch (...) {
50317       {
50318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50319       };
50320     }
50321   }
50322   jresult = result;
50323   return jresult;
50324 }
50325
50326
50327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
50328   void * jresult ;
50329   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
50330
50331   {
50332     try {
50333       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
50334     } catch (std::out_of_range& e) {
50335       {
50336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50337       };
50338     } catch (std::exception& e) {
50339       {
50340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50341       };
50342     } catch (...) {
50343       {
50344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50345       };
50346     }
50347   }
50348   jresult = (void *)result;
50349   return jresult;
50350 }
50351
50352
50353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
50354   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50355
50356   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50357   {
50358     try {
50359       delete arg1;
50360     } catch (std::out_of_range& e) {
50361       {
50362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50363       };
50364     } catch (std::exception& e) {
50365       {
50366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50367       };
50368     } catch (...) {
50369       {
50370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50371       };
50372     }
50373   }
50374 }
50375
50376
50377 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
50378   unsigned int jresult ;
50379   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50380   bool result;
50381
50382   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50383   {
50384     try {
50385       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);
50386     } catch (std::out_of_range& e) {
50387       {
50388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50389       };
50390     } catch (std::exception& e) {
50391       {
50392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50393       };
50394     } catch (...) {
50395       {
50396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50397       };
50398     }
50399   }
50400   jresult = result;
50401   return jresult;
50402 }
50403
50404
50405 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
50406   unsigned long jresult ;
50407   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50408   std::size_t result;
50409
50410   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50411   {
50412     try {
50413       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);
50414     } catch (std::out_of_range& e) {
50415       {
50416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50417       };
50418     } catch (std::exception& e) {
50419       {
50420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50421       };
50422     } catch (...) {
50423       {
50424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50425       };
50426     }
50427   }
50428   jresult = (unsigned long)result;
50429   return jresult;
50430 }
50431
50432
50433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
50434   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50435   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50436
50437   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50438   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50439   {
50440     try {
50441       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50442     } catch (std::out_of_range& e) {
50443       {
50444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50445       };
50446     } catch (std::exception& e) {
50447       {
50448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50449       };
50450     } catch (...) {
50451       {
50452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50453       };
50454     }
50455   }
50456 }
50457
50458
50459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
50460   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50461   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50462
50463   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50464   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50465   {
50466     try {
50467       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50468     } catch (std::out_of_range& e) {
50469       {
50470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50471       };
50472     } catch (std::exception& e) {
50473       {
50474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50475       };
50476     } catch (...) {
50477       {
50478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50479       };
50480     }
50481   }
50482 }
50483
50484
50485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50486   unsigned int jresult ;
50487   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50488   Dali::Actor arg2 ;
50489   Dali::HoverEvent *arg3 = 0 ;
50490   Dali::Actor *argp2 ;
50491   bool result;
50492
50493   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50494   argp2 = (Dali::Actor *)jarg2;
50495   if (!argp2) {
50496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50497     return 0;
50498   }
50499   arg2 = *argp2;
50500   arg3 = (Dali::HoverEvent *)jarg3;
50501   if (!arg3) {
50502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
50503     return 0;
50504   }
50505   {
50506     try {
50507       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
50508     } catch (std::out_of_range& e) {
50509       {
50510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50511       };
50512     } catch (std::exception& e) {
50513       {
50514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50515       };
50516     } catch (...) {
50517       {
50518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50519       };
50520     }
50521   }
50522   jresult = result;
50523   return jresult;
50524 }
50525
50526
50527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
50528   void * jresult ;
50529   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
50530
50531   {
50532     try {
50533       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
50534     } catch (std::out_of_range& e) {
50535       {
50536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50537       };
50538     } catch (std::exception& e) {
50539       {
50540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50541       };
50542     } catch (...) {
50543       {
50544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50545       };
50546     }
50547   }
50548   jresult = (void *)result;
50549   return jresult;
50550 }
50551
50552
50553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
50554   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50555
50556   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50557   {
50558     try {
50559       delete arg1;
50560     } catch (std::out_of_range& e) {
50561       {
50562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50563       };
50564     } catch (std::exception& e) {
50565       {
50566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50567       };
50568     } catch (...) {
50569       {
50570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50571       };
50572     }
50573   }
50574 }
50575
50576
50577 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
50578   unsigned int jresult ;
50579   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50580   bool result;
50581
50582   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50583   {
50584     try {
50585       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);
50586     } catch (std::out_of_range& e) {
50587       {
50588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50589       };
50590     } catch (std::exception& e) {
50591       {
50592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50593       };
50594     } catch (...) {
50595       {
50596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50597       };
50598     }
50599   }
50600   jresult = result;
50601   return jresult;
50602 }
50603
50604
50605 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
50606   unsigned long jresult ;
50607   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50608   std::size_t result;
50609
50610   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50611   {
50612     try {
50613       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);
50614     } catch (std::out_of_range& e) {
50615       {
50616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50617       };
50618     } catch (std::exception& e) {
50619       {
50620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50621       };
50622     } catch (...) {
50623       {
50624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50625       };
50626     }
50627   }
50628   jresult = (unsigned long)result;
50629   return jresult;
50630 }
50631
50632
50633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
50634   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50635   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50636
50637   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50638   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50639   {
50640     try {
50641       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50642     } catch (std::out_of_range& e) {
50643       {
50644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50645       };
50646     } catch (std::exception& e) {
50647       {
50648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50649       };
50650     } catch (...) {
50651       {
50652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50653       };
50654     }
50655   }
50656 }
50657
50658
50659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
50660   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50661   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50662
50663   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50664   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50665   {
50666     try {
50667       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50668     } catch (std::out_of_range& e) {
50669       {
50670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50671       };
50672     } catch (std::exception& e) {
50673       {
50674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50675       };
50676     } catch (...) {
50677       {
50678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50679       };
50680     }
50681   }
50682 }
50683
50684
50685 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50686   unsigned int jresult ;
50687   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50688   Dali::Actor arg2 ;
50689   Dali::WheelEvent *arg3 = 0 ;
50690   Dali::Actor *argp2 ;
50691   bool result;
50692
50693   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50694   argp2 = (Dali::Actor *)jarg2;
50695   if (!argp2) {
50696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50697     return 0;
50698   }
50699   arg2 = *argp2;
50700   arg3 = (Dali::WheelEvent *)jarg3;
50701   if (!arg3) {
50702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
50703     return 0;
50704   }
50705   {
50706     try {
50707       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
50708     } catch (std::out_of_range& e) {
50709       {
50710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50711       };
50712     } catch (std::exception& e) {
50713       {
50714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50715       };
50716     } catch (...) {
50717       {
50718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50719       };
50720     }
50721   }
50722   jresult = result;
50723   return jresult;
50724 }
50725
50726
50727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
50728   void * jresult ;
50729   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
50730
50731   {
50732     try {
50733       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
50734     } catch (std::out_of_range& e) {
50735       {
50736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50737       };
50738     } catch (std::exception& e) {
50739       {
50740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50741       };
50742     } catch (...) {
50743       {
50744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50745       };
50746     }
50747   }
50748   jresult = (void *)result;
50749   return jresult;
50750 }
50751
50752
50753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
50754   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50755
50756   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50757   {
50758     try {
50759       delete arg1;
50760     } catch (std::out_of_range& e) {
50761       {
50762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50763       };
50764     } catch (std::exception& e) {
50765       {
50766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50767       };
50768     } catch (...) {
50769       {
50770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50771       };
50772     }
50773   }
50774 }
50775
50776
50777 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
50778   unsigned int jresult ;
50779   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50780   bool result;
50781
50782   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50783   {
50784     try {
50785       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
50786     } catch (std::out_of_range& e) {
50787       {
50788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50789       };
50790     } catch (std::exception& e) {
50791       {
50792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50793       };
50794     } catch (...) {
50795       {
50796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50797       };
50798     }
50799   }
50800   jresult = result;
50801   return jresult;
50802 }
50803
50804
50805 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
50806   unsigned long jresult ;
50807   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50808   std::size_t result;
50809
50810   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50811   {
50812     try {
50813       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
50814     } catch (std::out_of_range& e) {
50815       {
50816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50817       };
50818     } catch (std::exception& e) {
50819       {
50820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50821       };
50822     } catch (...) {
50823       {
50824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50825       };
50826     }
50827   }
50828   jresult = (unsigned long)result;
50829   return jresult;
50830 }
50831
50832
50833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
50834   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50835   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50836
50837   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50838   arg2 = (void (*)(Dali::Actor))jarg2;
50839   {
50840     try {
50841       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
50842     } catch (std::out_of_range& e) {
50843       {
50844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50845       };
50846     } catch (std::exception& e) {
50847       {
50848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50849       };
50850     } catch (...) {
50851       {
50852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50853       };
50854     }
50855   }
50856 }
50857
50858
50859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
50860   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50861   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50862
50863   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50864   arg2 = (void (*)(Dali::Actor))jarg2;
50865   {
50866     try {
50867       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
50868     } catch (std::out_of_range& e) {
50869       {
50870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50871       };
50872     } catch (std::exception& e) {
50873       {
50874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50875       };
50876     } catch (...) {
50877       {
50878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50879       };
50880     }
50881   }
50882 }
50883
50884
50885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
50886   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50887   Dali::Actor arg2 ;
50888   Dali::Actor *argp2 ;
50889
50890   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50891   argp2 = (Dali::Actor *)jarg2;
50892   if (!argp2) {
50893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50894     return ;
50895   }
50896   arg2 = *argp2;
50897   {
50898     try {
50899       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
50900     } catch (std::out_of_range& e) {
50901       {
50902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50903       };
50904     } catch (std::exception& e) {
50905       {
50906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50907       };
50908     } catch (...) {
50909       {
50910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50911       };
50912     }
50913   }
50914 }
50915
50916
50917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
50918   void * jresult ;
50919   Dali::Signal< void (Dali::Actor) > *result = 0 ;
50920
50921   {
50922     try {
50923       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
50924     } catch (std::out_of_range& e) {
50925       {
50926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50927       };
50928     } catch (std::exception& e) {
50929       {
50930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50931       };
50932     } catch (...) {
50933       {
50934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50935       };
50936     }
50937   }
50938   jresult = (void *)result;
50939   return jresult;
50940 }
50941
50942
50943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
50944   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50945
50946   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50947   {
50948     try {
50949       delete arg1;
50950     } catch (std::out_of_range& e) {
50951       {
50952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50953       };
50954     } catch (std::exception& e) {
50955       {
50956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50957       };
50958     } catch (...) {
50959       {
50960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50961       };
50962     }
50963   }
50964 }
50965
50966
50967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
50968   unsigned int jresult ;
50969   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50970   bool result;
50971
50972   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50973   {
50974     try {
50975       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
50976     } catch (std::out_of_range& e) {
50977       {
50978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50979       };
50980     } catch (std::exception& e) {
50981       {
50982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50983       };
50984     } catch (...) {
50985       {
50986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50987       };
50988     }
50989   }
50990   jresult = result;
50991   return jresult;
50992 }
50993
50994
50995 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
50996   unsigned long jresult ;
50997   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50998   std::size_t result;
50999
51000   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51001   {
51002     try {
51003       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
51004     } catch (std::out_of_range& e) {
51005       {
51006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51007       };
51008     } catch (std::exception& e) {
51009       {
51010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51011       };
51012     } catch (...) {
51013       {
51014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51015       };
51016     }
51017   }
51018   jresult = (unsigned long)result;
51019   return jresult;
51020 }
51021
51022
51023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
51024   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51025   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
51026
51027   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51028   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
51029   {
51030     try {
51031       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51032     } catch (std::out_of_range& e) {
51033       {
51034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51035       };
51036     } catch (std::exception& e) {
51037       {
51038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51039       };
51040     } catch (...) {
51041       {
51042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51043       };
51044     }
51045   }
51046 }
51047
51048
51049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
51050   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51051   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
51052
51053   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51054   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
51055   {
51056     try {
51057       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51058     } catch (std::out_of_range& e) {
51059       {
51060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51061       };
51062     } catch (std::exception& e) {
51063       {
51064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51065       };
51066     } catch (...) {
51067       {
51068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51069       };
51070     }
51071   }
51072 }
51073
51074
51075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
51076   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51077   Dali::KeyEvent *arg2 = 0 ;
51078
51079   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51080   arg2 = (Dali::KeyEvent *)jarg2;
51081   if (!arg2) {
51082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
51083     return ;
51084   }
51085   {
51086     try {
51087       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
51088     } catch (std::out_of_range& e) {
51089       {
51090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51091       };
51092     } catch (std::exception& e) {
51093       {
51094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51095       };
51096     } catch (...) {
51097       {
51098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51099       };
51100     }
51101   }
51102 }
51103
51104
51105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
51106   void * jresult ;
51107   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
51108
51109   {
51110     try {
51111       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
51112     } catch (std::out_of_range& e) {
51113       {
51114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51115       };
51116     } catch (std::exception& e) {
51117       {
51118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51119       };
51120     } catch (...) {
51121       {
51122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51123       };
51124     }
51125   }
51126   jresult = (void *)result;
51127   return jresult;
51128 }
51129
51130
51131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
51132   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51133
51134   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51135   {
51136     try {
51137       delete arg1;
51138     } catch (std::out_of_range& e) {
51139       {
51140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51141       };
51142     } catch (std::exception& e) {
51143       {
51144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51145       };
51146     } catch (...) {
51147       {
51148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51149       };
51150     }
51151   }
51152 }
51153
51154
51155 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
51156   unsigned int jresult ;
51157   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51158   bool result;
51159
51160   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51161   {
51162     try {
51163       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
51164     } catch (std::out_of_range& e) {
51165       {
51166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51167       };
51168     } catch (std::exception& e) {
51169       {
51170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51171       };
51172     } catch (...) {
51173       {
51174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51175       };
51176     }
51177   }
51178   jresult = result;
51179   return jresult;
51180 }
51181
51182
51183 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
51184   unsigned long jresult ;
51185   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51186   std::size_t result;
51187
51188   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51189   {
51190     try {
51191       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
51192     } catch (std::out_of_range& e) {
51193       {
51194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51195       };
51196     } catch (std::exception& e) {
51197       {
51198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51199       };
51200     } catch (...) {
51201       {
51202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51203       };
51204     }
51205   }
51206   jresult = (unsigned long)result;
51207   return jresult;
51208 }
51209
51210
51211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
51212   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51213   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
51214
51215   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51216   arg2 = (void (*)(Dali::TouchData const &))jarg2;
51217   {
51218     try {
51219       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51220     } catch (std::out_of_range& e) {
51221       {
51222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51223       };
51224     } catch (std::exception& e) {
51225       {
51226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51227       };
51228     } catch (...) {
51229       {
51230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51231       };
51232     }
51233   }
51234 }
51235
51236
51237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
51238   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51239   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
51240
51241   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51242   arg2 = (void (*)(Dali::TouchData const &))jarg2;
51243   {
51244     try {
51245       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51246     } catch (std::out_of_range& e) {
51247       {
51248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51249       };
51250     } catch (std::exception& e) {
51251       {
51252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51253       };
51254     } catch (...) {
51255       {
51256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51257       };
51258     }
51259   }
51260 }
51261
51262
51263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
51264   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51265   Dali::TouchData *arg2 = 0 ;
51266
51267   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51268   arg2 = (Dali::TouchData *)jarg2;
51269   if (!arg2) {
51270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
51271     return ;
51272   }
51273   {
51274     try {
51275       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
51276     } catch (std::out_of_range& e) {
51277       {
51278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51279       };
51280     } catch (std::exception& e) {
51281       {
51282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51283       };
51284     } catch (...) {
51285       {
51286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51287       };
51288     }
51289   }
51290 }
51291
51292
51293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
51294   void * jresult ;
51295   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
51296
51297   {
51298     try {
51299       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
51300     } catch (std::out_of_range& e) {
51301       {
51302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51303       };
51304     } catch (std::exception& e) {
51305       {
51306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51307       };
51308     } catch (...) {
51309       {
51310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51311       };
51312     }
51313   }
51314   jresult = (void *)result;
51315   return jresult;
51316 }
51317
51318
51319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
51320   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51321
51322   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51323   {
51324     try {
51325       delete arg1;
51326     } catch (std::out_of_range& e) {
51327       {
51328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51329       };
51330     } catch (std::exception& e) {
51331       {
51332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51333       };
51334     } catch (...) {
51335       {
51336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51337       };
51338     }
51339   }
51340 }
51341
51342
51343 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
51344   unsigned int jresult ;
51345   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51346   bool result;
51347
51348   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51349   {
51350     try {
51351       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
51352     } catch (std::out_of_range& e) {
51353       {
51354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51355       };
51356     } catch (std::exception& e) {
51357       {
51358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51359       };
51360     } catch (...) {
51361       {
51362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51363       };
51364     }
51365   }
51366   jresult = result;
51367   return jresult;
51368 }
51369
51370
51371 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
51372   unsigned long jresult ;
51373   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51374   std::size_t result;
51375
51376   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51377   {
51378     try {
51379       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
51380     } catch (std::out_of_range& e) {
51381       {
51382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51383       };
51384     } catch (std::exception& e) {
51385       {
51386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51387       };
51388     } catch (...) {
51389       {
51390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51391       };
51392     }
51393   }
51394   jresult = (unsigned long)result;
51395   return jresult;
51396 }
51397
51398
51399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
51400   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51401   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51402
51403   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51404   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51405   {
51406     try {
51407       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51408     } catch (std::out_of_range& e) {
51409       {
51410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51411       };
51412     } catch (std::exception& e) {
51413       {
51414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51415       };
51416     } catch (...) {
51417       {
51418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51419       };
51420     }
51421   }
51422 }
51423
51424
51425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
51426   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51427   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51428
51429   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51430   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51431   {
51432     try {
51433       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51434     } catch (std::out_of_range& e) {
51435       {
51436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51437       };
51438     } catch (std::exception& e) {
51439       {
51440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51441       };
51442     } catch (...) {
51443       {
51444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51445       };
51446     }
51447   }
51448 }
51449
51450
51451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
51452   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51453   Dali::WheelEvent *arg2 = 0 ;
51454
51455   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51456   arg2 = (Dali::WheelEvent *)jarg2;
51457   if (!arg2) {
51458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
51459     return ;
51460   }
51461   {
51462     try {
51463       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
51464     } catch (std::out_of_range& e) {
51465       {
51466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51467       };
51468     } catch (std::exception& e) {
51469       {
51470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51471       };
51472     } catch (...) {
51473       {
51474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51475       };
51476     }
51477   }
51478 }
51479
51480
51481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
51482   void * jresult ;
51483   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
51484
51485   {
51486     try {
51487       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
51488     } catch (std::out_of_range& e) {
51489       {
51490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51491       };
51492     } catch (std::exception& e) {
51493       {
51494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51495       };
51496     } catch (...) {
51497       {
51498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51499       };
51500     }
51501   }
51502   jresult = (void *)result;
51503   return jresult;
51504 }
51505
51506
51507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
51508   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51509
51510   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51511   {
51512     try {
51513       delete arg1;
51514     } catch (std::out_of_range& e) {
51515       {
51516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51517       };
51518     } catch (std::exception& e) {
51519       {
51520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51521       };
51522     } catch (...) {
51523       {
51524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51525       };
51526     }
51527   }
51528 }
51529
51530
51531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
51532   void * jresult ;
51533   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51534
51535   {
51536     try {
51537       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
51538     } catch (std::out_of_range& e) {
51539       {
51540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51541       };
51542     } catch (std::exception& e) {
51543       {
51544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51545       };
51546     } catch (...) {
51547       {
51548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51549       };
51550     }
51551   }
51552   jresult = (void *)result;
51553   return jresult;
51554 }
51555
51556
51557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
51558   void * jresult ;
51559   Dali::Radian arg1 ;
51560   Dali::Radian arg2 ;
51561   Dali::Radian *argp1 ;
51562   Dali::Radian *argp2 ;
51563   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51564
51565   argp1 = (Dali::Radian *)jarg1;
51566   if (!argp1) {
51567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51568     return 0;
51569   }
51570   arg1 = *argp1;
51571   argp2 = (Dali::Radian *)jarg2;
51572   if (!argp2) {
51573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51574     return 0;
51575   }
51576   arg2 = *argp2;
51577   {
51578     try {
51579       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
51580     } catch (std::out_of_range& e) {
51581       {
51582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51583       };
51584     } catch (std::exception& e) {
51585       {
51586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51587       };
51588     } catch (...) {
51589       {
51590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51591       };
51592     }
51593   }
51594   jresult = (void *)result;
51595   return jresult;
51596 }
51597
51598
51599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
51600   void * jresult ;
51601   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
51602   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51603
51604   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51605   if (!arg1) {
51606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
51607     return 0;
51608   }
51609   {
51610     try {
51611       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
51612     } catch (std::out_of_range& e) {
51613       {
51614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51615       };
51616     } catch (std::exception& e) {
51617       {
51618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51619       };
51620     } catch (...) {
51621       {
51622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51623       };
51624     }
51625   }
51626   jresult = (void *)result;
51627   return jresult;
51628 }
51629
51630
51631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
51632   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51633   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51634
51635   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51636   arg2 = (Dali::Radian *)jarg2;
51637   if (arg1) (arg1)->first = *arg2;
51638 }
51639
51640
51641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
51642   void * jresult ;
51643   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51644   Dali::Radian *result = 0 ;
51645
51646   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51647   result = (Dali::Radian *)& ((arg1)->first);
51648   jresult = (void *)result;
51649   return jresult;
51650 }
51651
51652
51653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
51654   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51655   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51656
51657   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51658   arg2 = (Dali::Radian *)jarg2;
51659   if (arg1) (arg1)->second = *arg2;
51660 }
51661
51662
51663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
51664   void * jresult ;
51665   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51666   Dali::Radian *result = 0 ;
51667
51668   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51669   result = (Dali::Radian *)& ((arg1)->second);
51670   jresult = (void *)result;
51671   return jresult;
51672 }
51673
51674
51675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
51676   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51677
51678   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51679   {
51680     try {
51681       delete arg1;
51682     } catch (std::out_of_range& e) {
51683       {
51684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51685       };
51686     } catch (std::exception& e) {
51687       {
51688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51689       };
51690     } catch (...) {
51691       {
51692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51693       };
51694     }
51695   }
51696 }
51697
51698
51699 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
51700   unsigned int jresult ;
51701   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51702   bool result;
51703
51704   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51705   {
51706     try {
51707       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);
51708     } catch (std::out_of_range& e) {
51709       {
51710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51711       };
51712     } catch (std::exception& e) {
51713       {
51714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51715       };
51716     } catch (...) {
51717       {
51718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51719       };
51720     }
51721   }
51722   jresult = result;
51723   return jresult;
51724 }
51725
51726
51727 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51728   unsigned long jresult ;
51729   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51730   std::size_t result;
51731
51732   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51733   {
51734     try {
51735       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);
51736     } catch (std::out_of_range& e) {
51737       {
51738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51739       };
51740     } catch (std::exception& e) {
51741       {
51742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51743       };
51744     } catch (...) {
51745       {
51746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51747       };
51748     }
51749   }
51750   jresult = (unsigned long)result;
51751   return jresult;
51752 }
51753
51754
51755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51756   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51757   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51758
51759   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51760   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51761   {
51762     try {
51763       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51764     } catch (std::out_of_range& e) {
51765       {
51766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51767       };
51768     } catch (std::exception& e) {
51769       {
51770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51771       };
51772     } catch (...) {
51773       {
51774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51775       };
51776     }
51777   }
51778 }
51779
51780
51781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51782   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51783   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51784
51785   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51786   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51787   {
51788     try {
51789       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51790     } catch (std::out_of_range& e) {
51791       {
51792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51793       };
51794     } catch (std::exception& e) {
51795       {
51796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51797       };
51798     } catch (...) {
51799       {
51800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51801       };
51802     }
51803   }
51804 }
51805
51806
51807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51808   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51809   Dali::Actor arg2 ;
51810   Dali::PanGesture *arg3 = 0 ;
51811   Dali::Actor *argp2 ;
51812
51813   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51814   argp2 = (Dali::Actor *)jarg2;
51815   if (!argp2) {
51816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51817     return ;
51818   }
51819   arg2 = *argp2;
51820   arg3 = (Dali::PanGesture *)jarg3;
51821   if (!arg3) {
51822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
51823     return ;
51824   }
51825   {
51826     try {
51827       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
51828     } catch (std::out_of_range& e) {
51829       {
51830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51831       };
51832     } catch (std::exception& e) {
51833       {
51834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51835       };
51836     } catch (...) {
51837       {
51838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51839       };
51840     }
51841   }
51842 }
51843
51844
51845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
51846   void * jresult ;
51847   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
51848
51849   {
51850     try {
51851       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
51852     } catch (std::out_of_range& e) {
51853       {
51854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51855       };
51856     } catch (std::exception& e) {
51857       {
51858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51859       };
51860     } catch (...) {
51861       {
51862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51863       };
51864     }
51865   }
51866   jresult = (void *)result;
51867   return jresult;
51868 }
51869
51870
51871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
51872   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51873
51874   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51875   {
51876     try {
51877       delete arg1;
51878     } catch (std::out_of_range& e) {
51879       {
51880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51881       };
51882     } catch (std::exception& e) {
51883       {
51884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51885       };
51886     } catch (...) {
51887       {
51888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51889       };
51890     }
51891   }
51892 }
51893
51894
51895 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
51896   unsigned int jresult ;
51897   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51898   bool result;
51899
51900   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51901   {
51902     try {
51903       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);
51904     } catch (std::out_of_range& e) {
51905       {
51906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51907       };
51908     } catch (std::exception& e) {
51909       {
51910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51911       };
51912     } catch (...) {
51913       {
51914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51915       };
51916     }
51917   }
51918   jresult = result;
51919   return jresult;
51920 }
51921
51922
51923 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51924   unsigned long jresult ;
51925   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51926   std::size_t result;
51927
51928   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51929   {
51930     try {
51931       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);
51932     } catch (std::out_of_range& e) {
51933       {
51934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51935       };
51936     } catch (std::exception& e) {
51937       {
51938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51939       };
51940     } catch (...) {
51941       {
51942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51943       };
51944     }
51945   }
51946   jresult = (unsigned long)result;
51947   return jresult;
51948 }
51949
51950
51951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51952   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51953   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
51954
51955   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51956   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
51957   {
51958     try {
51959       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51960     } catch (std::out_of_range& e) {
51961       {
51962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51963       };
51964     } catch (std::exception& e) {
51965       {
51966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51967       };
51968     } catch (...) {
51969       {
51970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51971       };
51972     }
51973   }
51974 }
51975
51976
51977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51978   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51979   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
51980
51981   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51982   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
51983   {
51984     try {
51985       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51986     } catch (std::out_of_range& e) {
51987       {
51988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51989       };
51990     } catch (std::exception& e) {
51991       {
51992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51993       };
51994     } catch (...) {
51995       {
51996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51997       };
51998     }
51999   }
52000 }
52001
52002
52003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52004   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
52005   Dali::Actor arg2 ;
52006   Dali::PinchGesture *arg3 = 0 ;
52007   Dali::Actor *argp2 ;
52008
52009   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
52010   argp2 = (Dali::Actor *)jarg2;
52011   if (!argp2) {
52012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52013     return ;
52014   }
52015   arg2 = *argp2;
52016   arg3 = (Dali::PinchGesture *)jarg3;
52017   if (!arg3) {
52018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
52019     return ;
52020   }
52021   {
52022     try {
52023       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
52024     } catch (std::out_of_range& e) {
52025       {
52026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52027       };
52028     } catch (std::exception& e) {
52029       {
52030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52031       };
52032     } catch (...) {
52033       {
52034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52035       };
52036     }
52037   }
52038 }
52039
52040
52041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
52042   void * jresult ;
52043   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
52044
52045   {
52046     try {
52047       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
52048     } catch (std::out_of_range& e) {
52049       {
52050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52051       };
52052     } catch (std::exception& e) {
52053       {
52054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52055       };
52056     } catch (...) {
52057       {
52058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52059       };
52060     }
52061   }
52062   jresult = (void *)result;
52063   return jresult;
52064 }
52065
52066
52067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
52068   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
52069
52070   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
52071   {
52072     try {
52073       delete arg1;
52074     } catch (std::out_of_range& e) {
52075       {
52076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52077       };
52078     } catch (std::exception& e) {
52079       {
52080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52081       };
52082     } catch (...) {
52083       {
52084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52085       };
52086     }
52087   }
52088 }
52089
52090
52091 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
52092   unsigned int jresult ;
52093   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52094   bool result;
52095
52096   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52097   {
52098     try {
52099       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);
52100     } catch (std::out_of_range& e) {
52101       {
52102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52103       };
52104     } catch (std::exception& e) {
52105       {
52106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52107       };
52108     } catch (...) {
52109       {
52110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52111       };
52112     }
52113   }
52114   jresult = result;
52115   return jresult;
52116 }
52117
52118
52119 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
52120   unsigned long jresult ;
52121   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52122   std::size_t result;
52123
52124   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52125   {
52126     try {
52127       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);
52128     } catch (std::out_of_range& e) {
52129       {
52130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52131       };
52132     } catch (std::exception& e) {
52133       {
52134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52135       };
52136     } catch (...) {
52137       {
52138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52139       };
52140     }
52141   }
52142   jresult = (unsigned long)result;
52143   return jresult;
52144 }
52145
52146
52147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
52148   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52149   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
52150
52151   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52152   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
52153   {
52154     try {
52155       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52156     } catch (std::out_of_range& e) {
52157       {
52158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52159       };
52160     } catch (std::exception& e) {
52161       {
52162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52163       };
52164     } catch (...) {
52165       {
52166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52167       };
52168     }
52169   }
52170 }
52171
52172
52173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
52174   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52175   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
52176
52177   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52178   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
52179   {
52180     try {
52181       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52182     } catch (std::out_of_range& e) {
52183       {
52184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52185       };
52186     } catch (std::exception& e) {
52187       {
52188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52189       };
52190     } catch (...) {
52191       {
52192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52193       };
52194     }
52195   }
52196 }
52197
52198
52199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52200   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52201   Dali::Actor arg2 ;
52202   Dali::TapGesture *arg3 = 0 ;
52203   Dali::Actor *argp2 ;
52204
52205   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52206   argp2 = (Dali::Actor *)jarg2;
52207   if (!argp2) {
52208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52209     return ;
52210   }
52211   arg2 = *argp2;
52212   arg3 = (Dali::TapGesture *)jarg3;
52213   if (!arg3) {
52214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
52215     return ;
52216   }
52217   {
52218     try {
52219       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
52220     } catch (std::out_of_range& e) {
52221       {
52222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52223       };
52224     } catch (std::exception& e) {
52225       {
52226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52227       };
52228     } catch (...) {
52229       {
52230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52231       };
52232     }
52233   }
52234 }
52235
52236
52237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
52238   void * jresult ;
52239   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
52240
52241   {
52242     try {
52243       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
52244     } catch (std::out_of_range& e) {
52245       {
52246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52247       };
52248     } catch (std::exception& e) {
52249       {
52250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52251       };
52252     } catch (...) {
52253       {
52254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52255       };
52256     }
52257   }
52258   jresult = (void *)result;
52259   return jresult;
52260 }
52261
52262
52263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
52264   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52265
52266   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52267   {
52268     try {
52269       delete arg1;
52270     } catch (std::out_of_range& e) {
52271       {
52272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52273       };
52274     } catch (std::exception& e) {
52275       {
52276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52277       };
52278     } catch (...) {
52279       {
52280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52281       };
52282     }
52283   }
52284 }
52285
52286
52287 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AnimationSignal_Empty(void * jarg1) {
52288   unsigned int jresult ;
52289   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52290   bool result;
52291
52292   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52293   {
52294     try {
52295       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Animation &) > const *)arg1);
52296     } catch (std::out_of_range& e) {
52297       {
52298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52299       };
52300     } catch (std::exception& e) {
52301       {
52302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52303       };
52304     } catch (...) {
52305       {
52306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52307       };
52308     }
52309   }
52310   jresult = result;
52311   return jresult;
52312 }
52313
52314
52315 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AnimationSignal_GetConnectionCount(void * jarg1) {
52316   unsigned long jresult ;
52317   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52318   std::size_t result;
52319
52320   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52321   {
52322     try {
52323       result = Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Animation &) > const *)arg1);
52324     } catch (std::out_of_range& e) {
52325       {
52326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52327       };
52328     } catch (std::exception& e) {
52329       {
52330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52331       };
52332     } catch (...) {
52333       {
52334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52335       };
52336     }
52337   }
52338   jresult = (unsigned long)result;
52339   return jresult;
52340 }
52341
52342
52343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Connect(void * jarg1, void * jarg2) {
52344   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52345   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52346
52347   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52348   arg2 = (void (*)(Dali::Animation &))jarg2;
52349   {
52350     try {
52351       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(arg1,arg2);
52352     } catch (std::out_of_range& e) {
52353       {
52354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52355       };
52356     } catch (std::exception& e) {
52357       {
52358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52359       };
52360     } catch (...) {
52361       {
52362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52363       };
52364     }
52365   }
52366 }
52367
52368
52369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Disconnect(void * jarg1, void * jarg2) {
52370   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52371   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52372
52373   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52374   arg2 = (void (*)(Dali::Animation &))jarg2;
52375   {
52376     try {
52377       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(arg1,arg2);
52378     } catch (std::out_of_range& e) {
52379       {
52380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52381       };
52382     } catch (std::exception& e) {
52383       {
52384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52385       };
52386     } catch (...) {
52387       {
52388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52389       };
52390     }
52391   }
52392 }
52393
52394
52395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Emit(void * jarg1, void * jarg2) {
52396   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52397   Dali::Animation *arg2 = 0 ;
52398
52399   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52400   arg2 = (Dali::Animation *)jarg2;
52401   if (!arg2) {
52402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
52403     return ;
52404   }
52405   {
52406     try {
52407       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(arg1,*arg2);
52408     } catch (std::out_of_range& e) {
52409       {
52410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52411       };
52412     } catch (std::exception& e) {
52413       {
52414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52415       };
52416     } catch (...) {
52417       {
52418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52419       };
52420     }
52421   }
52422 }
52423
52424
52425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimationSignal() {
52426   void * jresult ;
52427   Dali::Signal< void (Dali::Animation &) > *result = 0 ;
52428
52429   {
52430     try {
52431       result = (Dali::Signal< void (Dali::Animation &) > *)new Dali::Signal< void (Dali::Animation &) >();
52432     } catch (std::out_of_range& e) {
52433       {
52434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52435       };
52436     } catch (std::exception& e) {
52437       {
52438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52439       };
52440     } catch (...) {
52441       {
52442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52443       };
52444     }
52445   }
52446   jresult = (void *)result;
52447   return jresult;
52448 }
52449
52450
52451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimationSignal(void * jarg1) {
52452   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52453
52454   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52455   {
52456     try {
52457       delete arg1;
52458     } catch (std::out_of_range& e) {
52459       {
52460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52461       };
52462     } catch (std::exception& e) {
52463       {
52464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52465       };
52466     } catch (...) {
52467       {
52468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52469       };
52470     }
52471   }
52472 }
52473
52474
52475 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
52476   unsigned int jresult ;
52477   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52478   bool result;
52479
52480   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52481   {
52482     try {
52483       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52484     } catch (std::out_of_range& e) {
52485       {
52486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52487       };
52488     } catch (std::exception& e) {
52489       {
52490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52491       };
52492     } catch (...) {
52493       {
52494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52495       };
52496     }
52497   }
52498   jresult = result;
52499   return jresult;
52500 }
52501
52502
52503 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
52504   unsigned long jresult ;
52505   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52506   std::size_t result;
52507
52508   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52509   {
52510     try {
52511       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52512     } catch (std::out_of_range& e) {
52513       {
52514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52515       };
52516     } catch (std::exception& e) {
52517       {
52518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52519       };
52520     } catch (...) {
52521       {
52522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52523       };
52524     }
52525   }
52526   jresult = (unsigned long)result;
52527   return jresult;
52528 }
52529
52530
52531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
52532   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52533   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52534
52535   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52536   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52537   {
52538     try {
52539       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
52540     } catch (std::out_of_range& e) {
52541       {
52542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52543       };
52544     } catch (std::exception& e) {
52545       {
52546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52547       };
52548     } catch (...) {
52549       {
52550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52551       };
52552     }
52553   }
52554 }
52555
52556
52557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
52558   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52559   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52560
52561   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52562   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52563   {
52564     try {
52565       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
52566     } catch (std::out_of_range& e) {
52567       {
52568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52569       };
52570     } catch (std::exception& e) {
52571       {
52572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52573       };
52574     } catch (...) {
52575       {
52576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52577       };
52578     }
52579   }
52580 }
52581
52582
52583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
52584   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52585   Dali::ResourceImage arg2 ;
52586   Dali::ResourceImage *argp2 ;
52587
52588   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52589   argp2 = (Dali::ResourceImage *)jarg2;
52590   if (!argp2) {
52591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
52592     return ;
52593   }
52594   arg2 = *argp2;
52595   {
52596     try {
52597       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
52598     } catch (std::out_of_range& e) {
52599       {
52600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52601       };
52602     } catch (std::exception& e) {
52603       {
52604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52605       };
52606     } catch (...) {
52607       {
52608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52609       };
52610     }
52611   }
52612 }
52613
52614
52615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
52616   void * jresult ;
52617   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
52618
52619   {
52620     try {
52621       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
52622     } catch (std::out_of_range& e) {
52623       {
52624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52625       };
52626     } catch (std::exception& e) {
52627       {
52628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52629       };
52630     } catch (...) {
52631       {
52632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52633       };
52634     }
52635   }
52636   jresult = (void *)result;
52637   return jresult;
52638 }
52639
52640
52641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
52642   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52643
52644   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52645   {
52646     try {
52647       delete arg1;
52648     } catch (std::out_of_range& e) {
52649       {
52650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52651       };
52652     } catch (std::exception& e) {
52653       {
52654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52655       };
52656     } catch (...) {
52657       {
52658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52659       };
52660     }
52661   }
52662 }
52663
52664
52665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
52666   void * jresult ;
52667   Dali::Timer *result = 0 ;
52668
52669   {
52670     try {
52671       result = (Dali::Timer *)new Dali::Timer();
52672     } catch (std::out_of_range& e) {
52673       {
52674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52675       };
52676     } catch (std::exception& e) {
52677       {
52678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52679       };
52680     } catch (...) {
52681       {
52682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52683       };
52684     }
52685   }
52686   jresult = (void *)result;
52687   return jresult;
52688 }
52689
52690
52691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
52692   void * jresult ;
52693   unsigned int arg1 ;
52694   Dali::Timer result;
52695
52696   arg1 = (unsigned int)jarg1;
52697   {
52698     try {
52699       result = Dali::Timer::New(arg1);
52700     } catch (std::out_of_range& e) {
52701       {
52702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52703       };
52704     } catch (std::exception& e) {
52705       {
52706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52707       };
52708     } catch (...) {
52709       {
52710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52711       };
52712     }
52713   }
52714   jresult = new Dali::Timer((const Dali::Timer &)result);
52715   return jresult;
52716 }
52717
52718
52719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
52720   void * jresult ;
52721   Dali::Timer *arg1 = 0 ;
52722   Dali::Timer *result = 0 ;
52723
52724   arg1 = (Dali::Timer *)jarg1;
52725   if (!arg1) {
52726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52727     return 0;
52728   }
52729   {
52730     try {
52731       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
52732     } catch (std::out_of_range& e) {
52733       {
52734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52735       };
52736     } catch (std::exception& e) {
52737       {
52738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52739       };
52740     } catch (...) {
52741       {
52742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52743       };
52744     }
52745   }
52746   jresult = (void *)result;
52747   return jresult;
52748 }
52749
52750
52751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
52752   void * jresult ;
52753   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52754   Dali::Timer *arg2 = 0 ;
52755   Dali::Timer *result = 0 ;
52756
52757   arg1 = (Dali::Timer *)jarg1;
52758   arg2 = (Dali::Timer *)jarg2;
52759   if (!arg2) {
52760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52761     return 0;
52762   }
52763   {
52764     try {
52765       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
52766     } catch (std::out_of_range& e) {
52767       {
52768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52769       };
52770     } catch (std::exception& e) {
52771       {
52772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52773       };
52774     } catch (...) {
52775       {
52776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52777       };
52778     }
52779   }
52780   jresult = (void *)result;
52781   return jresult;
52782 }
52783
52784
52785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
52786   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52787
52788   arg1 = (Dali::Timer *)jarg1;
52789   {
52790     try {
52791       delete arg1;
52792     } catch (std::out_of_range& e) {
52793       {
52794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52795       };
52796     } catch (std::exception& e) {
52797       {
52798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52799       };
52800     } catch (...) {
52801       {
52802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52803       };
52804     }
52805   }
52806 }
52807
52808
52809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
52810   void * jresult ;
52811   Dali::BaseHandle arg1 ;
52812   Dali::BaseHandle *argp1 ;
52813   Dali::Timer result;
52814
52815   argp1 = (Dali::BaseHandle *)jarg1;
52816   if (!argp1) {
52817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
52818     return 0;
52819   }
52820   arg1 = *argp1;
52821   {
52822     try {
52823       result = Dali::Timer::DownCast(arg1);
52824     } catch (std::out_of_range& e) {
52825       {
52826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52827       };
52828     } catch (std::exception& e) {
52829       {
52830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52831       };
52832     } catch (...) {
52833       {
52834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52835       };
52836     }
52837   }
52838   jresult = new Dali::Timer((const Dali::Timer &)result);
52839   return jresult;
52840 }
52841
52842
52843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
52844   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52845
52846   arg1 = (Dali::Timer *)jarg1;
52847   {
52848     try {
52849       (arg1)->Start();
52850     } catch (std::out_of_range& e) {
52851       {
52852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52853       };
52854     } catch (std::exception& e) {
52855       {
52856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52857       };
52858     } catch (...) {
52859       {
52860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52861       };
52862     }
52863   }
52864 }
52865
52866
52867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
52868   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52869
52870   arg1 = (Dali::Timer *)jarg1;
52871   {
52872     try {
52873       (arg1)->Stop();
52874     } catch (std::out_of_range& e) {
52875       {
52876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52877       };
52878     } catch (std::exception& e) {
52879       {
52880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52881       };
52882     } catch (...) {
52883       {
52884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52885       };
52886     }
52887   }
52888 }
52889
52890
52891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
52892   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52893   unsigned int arg2 ;
52894
52895   arg1 = (Dali::Timer *)jarg1;
52896   arg2 = (unsigned int)jarg2;
52897   {
52898     try {
52899       (arg1)->SetInterval(arg2);
52900     } catch (std::out_of_range& e) {
52901       {
52902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52903       };
52904     } catch (std::exception& e) {
52905       {
52906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52907       };
52908     } catch (...) {
52909       {
52910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52911       };
52912     }
52913   }
52914 }
52915
52916
52917 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
52918   unsigned int jresult ;
52919   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52920   unsigned int result;
52921
52922   arg1 = (Dali::Timer *)jarg1;
52923   {
52924     try {
52925       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
52926     } catch (std::out_of_range& e) {
52927       {
52928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52929       };
52930     } catch (std::exception& e) {
52931       {
52932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52933       };
52934     } catch (...) {
52935       {
52936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52937       };
52938     }
52939   }
52940   jresult = result;
52941   return jresult;
52942 }
52943
52944
52945 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
52946   unsigned int jresult ;
52947   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52948   bool result;
52949
52950   arg1 = (Dali::Timer *)jarg1;
52951   {
52952     try {
52953       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
52954     } catch (std::out_of_range& e) {
52955       {
52956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52957       };
52958     } catch (std::exception& e) {
52959       {
52960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52961       };
52962     } catch (...) {
52963       {
52964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52965       };
52966     }
52967   }
52968   jresult = result;
52969   return jresult;
52970 }
52971
52972
52973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
52974   void * jresult ;
52975   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52976   Dali::Timer::TimerSignalType *result = 0 ;
52977
52978   arg1 = (Dali::Timer *)jarg1;
52979   {
52980     try {
52981       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
52982     } catch (std::out_of_range& e) {
52983       {
52984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52985       };
52986     } catch (std::exception& e) {
52987       {
52988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52989       };
52990     } catch (...) {
52991       {
52992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52993       };
52994     }
52995   }
52996   jresult = (void *)result;
52997   return jresult;
52998 }
52999
53000
53001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
53002   void * jresult ;
53003   Dali::DragAndDropDetector *result = 0 ;
53004
53005   {
53006     try {
53007       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
53008     } catch (std::out_of_range& e) {
53009       {
53010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53011       };
53012     } catch (std::exception& e) {
53013       {
53014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53015       };
53016     } catch (...) {
53017       {
53018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53019       };
53020     }
53021   }
53022   jresult = (void *)result;
53023   return jresult;
53024 }
53025
53026
53027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
53028   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53029
53030   arg1 = (Dali::DragAndDropDetector *)jarg1;
53031   {
53032     try {
53033       delete arg1;
53034     } catch (std::out_of_range& e) {
53035       {
53036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53037       };
53038     } catch (std::exception& e) {
53039       {
53040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53041       };
53042     } catch (...) {
53043       {
53044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53045       };
53046     }
53047   }
53048 }
53049
53050
53051 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
53052   char * jresult ;
53053   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53054   std::string *result = 0 ;
53055
53056   arg1 = (Dali::DragAndDropDetector *)jarg1;
53057   {
53058     try {
53059       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
53060     } catch (std::out_of_range& e) {
53061       {
53062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53063       };
53064     } catch (std::exception& e) {
53065       {
53066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53067       };
53068     } catch (...) {
53069       {
53070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53071       };
53072     }
53073   }
53074   jresult = SWIG_csharp_string_callback(result->c_str());
53075   return jresult;
53076 }
53077
53078
53079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
53080   void * jresult ;
53081   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53082   Dali::Vector2 result;
53083
53084   arg1 = (Dali::DragAndDropDetector *)jarg1;
53085   {
53086     try {
53087       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
53088     } catch (std::out_of_range& e) {
53089       {
53090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53091       };
53092     } catch (std::exception& e) {
53093       {
53094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53095       };
53096     } catch (...) {
53097       {
53098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53099       };
53100     }
53101   }
53102   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
53103   return jresult;
53104 }
53105
53106
53107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
53108   void * jresult ;
53109   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53110   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53111
53112   arg1 = (Dali::DragAndDropDetector *)jarg1;
53113   {
53114     try {
53115       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
53116     } catch (std::out_of_range& e) {
53117       {
53118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53119       };
53120     } catch (std::exception& e) {
53121       {
53122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53123       };
53124     } catch (...) {
53125       {
53126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53127       };
53128     }
53129   }
53130   jresult = (void *)result;
53131   return jresult;
53132 }
53133
53134
53135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
53136   void * jresult ;
53137   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53138   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53139
53140   arg1 = (Dali::DragAndDropDetector *)jarg1;
53141   {
53142     try {
53143       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
53144     } catch (std::out_of_range& e) {
53145       {
53146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53147       };
53148     } catch (std::exception& e) {
53149       {
53150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53151       };
53152     } catch (...) {
53153       {
53154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53155       };
53156     }
53157   }
53158   jresult = (void *)result;
53159   return jresult;
53160 }
53161
53162
53163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
53164   void * jresult ;
53165   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53166   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53167
53168   arg1 = (Dali::DragAndDropDetector *)jarg1;
53169   {
53170     try {
53171       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
53172     } catch (std::out_of_range& e) {
53173       {
53174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53175       };
53176     } catch (std::exception& e) {
53177       {
53178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53179       };
53180     } catch (...) {
53181       {
53182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53183       };
53184     }
53185   }
53186   jresult = (void *)result;
53187   return jresult;
53188 }
53189
53190
53191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
53192   void * jresult ;
53193   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53194   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53195
53196   arg1 = (Dali::DragAndDropDetector *)jarg1;
53197   {
53198     try {
53199       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
53200     } catch (std::out_of_range& e) {
53201       {
53202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53203       };
53204     } catch (std::exception& e) {
53205       {
53206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53207       };
53208     } catch (...) {
53209       {
53210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53211       };
53212     }
53213   }
53214   jresult = (void *)result;
53215   return jresult;
53216 }
53217
53218
53219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
53220   void * jresult ;
53221   Dali::ApplicationExtensions *result = 0 ;
53222
53223   {
53224     try {
53225       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
53226     } catch (std::out_of_range& e) {
53227       {
53228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53229       };
53230     } catch (std::exception& e) {
53231       {
53232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53233       };
53234     } catch (...) {
53235       {
53236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53237       };
53238     }
53239   }
53240   jresult = (void *)result;
53241   return jresult;
53242 }
53243
53244
53245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
53246   void * jresult ;
53247   Dali::Application *arg1 = (Dali::Application *) 0 ;
53248   Dali::ApplicationExtensions *result = 0 ;
53249
53250   arg1 = (Dali::Application *)jarg1;
53251   {
53252     try {
53253       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
53254     } catch (std::out_of_range& e) {
53255       {
53256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53257       };
53258     } catch (std::exception& e) {
53259       {
53260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53261       };
53262     } catch (...) {
53263       {
53264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53265       };
53266     }
53267   }
53268   jresult = (void *)result;
53269   return jresult;
53270 }
53271
53272
53273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
53274   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53275
53276   arg1 = (Dali::ApplicationExtensions *)jarg1;
53277   {
53278     try {
53279       delete arg1;
53280     } catch (std::out_of_range& e) {
53281       {
53282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53283       };
53284     } catch (std::exception& e) {
53285       {
53286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53287       };
53288     } catch (...) {
53289       {
53290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53291       };
53292     }
53293   }
53294 }
53295
53296
53297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Init(void * jarg1) {
53298   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53299
53300   arg1 = (Dali::ApplicationExtensions *)jarg1;
53301   {
53302     try {
53303       (arg1)->Init();
53304     } catch (std::out_of_range& e) {
53305       {
53306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53307       };
53308     } catch (std::exception& e) {
53309       {
53310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53311       };
53312     } catch (...) {
53313       {
53314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53315       };
53316     }
53317   }
53318 }
53319
53320
53321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
53322   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53323
53324   arg1 = (Dali::ApplicationExtensions *)jarg1;
53325   {
53326     try {
53327       (arg1)->Terminate();
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_ApplicationExtensions_Pause(void * jarg1) {
53346   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53347
53348   arg1 = (Dali::ApplicationExtensions *)jarg1;
53349   {
53350     try {
53351       (arg1)->Pause();
53352     } catch (std::out_of_range& e) {
53353       {
53354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53355       };
53356     } catch (std::exception& e) {
53357       {
53358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53359       };
53360     } catch (...) {
53361       {
53362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53363       };
53364     }
53365   }
53366 }
53367
53368
53369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
53370   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53371
53372   arg1 = (Dali::ApplicationExtensions *)jarg1;
53373   {
53374     try {
53375       (arg1)->Resume();
53376     } catch (std::out_of_range& e) {
53377       {
53378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53379       };
53380     } catch (std::exception& e) {
53381       {
53382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53383       };
53384     } catch (...) {
53385       {
53386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53387       };
53388     }
53389   }
53390 }
53391
53392
53393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
53394   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53395
53396   arg1 = (Dali::ApplicationExtensions *)jarg1;
53397   {
53398     try {
53399       (arg1)->LanguageChange();
53400     } catch (std::out_of_range& e) {
53401       {
53402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53403       };
53404     } catch (std::exception& e) {
53405       {
53406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53407       };
53408     } catch (...) {
53409       {
53410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53411       };
53412     }
53413   }
53414 }
53415
53416
53417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3) {
53418   void * jresult ;
53419   Dali::PositionSize arg1 ;
53420   std::string *arg2 = 0 ;
53421   bool arg3 ;
53422   Dali::PositionSize *argp1 ;
53423   Dali::Window result;
53424
53425   argp1 = (Dali::PositionSize *)jarg1;
53426   if (!argp1) {
53427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53428     return 0;
53429   }
53430   arg1 = *argp1;
53431   if (!jarg2) {
53432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53433     return 0;
53434   }
53435   std::string arg2_str(jarg2);
53436   arg2 = &arg2_str;
53437   arg3 = jarg3 ? true : false;
53438   {
53439     try {
53440       result = Dali::Window::New(arg1,(std::string const &)*arg2,arg3);
53441     } catch (std::out_of_range& e) {
53442       {
53443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53444       };
53445     } catch (std::exception& e) {
53446       {
53447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53448       };
53449     } catch (...) {
53450       {
53451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53452       };
53453     }
53454   }
53455   jresult = new Dali::Window((const Dali::Window &)result);
53456
53457   //argout typemap for const std::string&
53458
53459   return jresult;
53460 }
53461
53462
53463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_1(void * jarg1, char * jarg2) {
53464   void * jresult ;
53465   Dali::PositionSize arg1 ;
53466   std::string *arg2 = 0 ;
53467   Dali::PositionSize *argp1 ;
53468   Dali::Window result;
53469
53470   argp1 = (Dali::PositionSize *)jarg1;
53471   if (!argp1) {
53472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53473     return 0;
53474   }
53475   arg1 = *argp1;
53476   if (!jarg2) {
53477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53478     return 0;
53479   }
53480   std::string arg2_str(jarg2);
53481   arg2 = &arg2_str;
53482   {
53483     try {
53484       result = Dali::Window::New(arg1,(std::string const &)*arg2);
53485     } catch (std::out_of_range& e) {
53486       {
53487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53488       };
53489     } catch (std::exception& e) {
53490       {
53491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53492       };
53493     } catch (...) {
53494       {
53495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53496       };
53497     }
53498   }
53499   jresult = new Dali::Window((const Dali::Window &)result);
53500
53501   //argout typemap for const std::string&
53502
53503   return jresult;
53504 }
53505
53506
53507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_2(void * jarg1, char * jarg2, char * jarg3, unsigned int jarg4) {
53508   void * jresult ;
53509   Dali::PositionSize arg1 ;
53510   std::string *arg2 = 0 ;
53511   std::string *arg3 = 0 ;
53512   bool arg4 ;
53513   Dali::PositionSize *argp1 ;
53514   Dali::Window result;
53515
53516   argp1 = (Dali::PositionSize *)jarg1;
53517   if (!argp1) {
53518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53519     return 0;
53520   }
53521   arg1 = *argp1;
53522   if (!jarg2) {
53523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53524     return 0;
53525   }
53526   std::string arg2_str(jarg2);
53527   arg2 = &arg2_str;
53528   if (!jarg3) {
53529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53530     return 0;
53531   }
53532   std::string arg3_str(jarg3);
53533   arg3 = &arg3_str;
53534   arg4 = jarg4 ? true : false;
53535   {
53536     try {
53537       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4);
53538     } catch (std::out_of_range& e) {
53539       {
53540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53541       };
53542     } catch (std::exception& e) {
53543       {
53544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53545       };
53546     } catch (...) {
53547       {
53548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53549       };
53550     }
53551   }
53552   jresult = new Dali::Window((const Dali::Window &)result);
53553
53554   //argout typemap for const std::string&
53555
53556
53557   //argout typemap for const std::string&
53558
53559   return jresult;
53560 }
53561
53562
53563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_3(void * jarg1, char * jarg2, char * jarg3) {
53564   void * jresult ;
53565   Dali::PositionSize arg1 ;
53566   std::string *arg2 = 0 ;
53567   std::string *arg3 = 0 ;
53568   Dali::PositionSize *argp1 ;
53569   Dali::Window result;
53570
53571   argp1 = (Dali::PositionSize *)jarg1;
53572   if (!argp1) {
53573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53574     return 0;
53575   }
53576   arg1 = *argp1;
53577   if (!jarg2) {
53578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53579     return 0;
53580   }
53581   std::string arg2_str(jarg2);
53582   arg2 = &arg2_str;
53583   if (!jarg3) {
53584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53585     return 0;
53586   }
53587   std::string arg3_str(jarg3);
53588   arg3 = &arg3_str;
53589   {
53590     try {
53591       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
53592     } catch (std::out_of_range& e) {
53593       {
53594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53595       };
53596     } catch (std::exception& e) {
53597       {
53598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53599       };
53600     } catch (...) {
53601       {
53602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53603       };
53604     }
53605   }
53606   jresult = new Dali::Window((const Dali::Window &)result);
53607
53608   //argout typemap for const std::string&
53609
53610
53611   //argout typemap for const std::string&
53612
53613   return jresult;
53614 }
53615
53616
53617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_0() {
53618   void * jresult ;
53619   Dali::Window *result = 0 ;
53620
53621   {
53622     try {
53623       result = (Dali::Window *)new Dali::Window();
53624     } catch (std::out_of_range& e) {
53625       {
53626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53627       };
53628     } catch (std::exception& e) {
53629       {
53630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53631       };
53632     } catch (...) {
53633       {
53634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53635       };
53636     }
53637   }
53638   jresult = (void *)result;
53639   return jresult;
53640 }
53641
53642
53643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Window(void * jarg1) {
53644   Dali::Window *arg1 = (Dali::Window *) 0 ;
53645
53646   arg1 = (Dali::Window *)jarg1;
53647   {
53648     try {
53649       delete arg1;
53650     } catch (std::out_of_range& e) {
53651       {
53652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53653       };
53654     } catch (std::exception& e) {
53655       {
53656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53657       };
53658     } catch (...) {
53659       {
53660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53661       };
53662     }
53663   }
53664 }
53665
53666
53667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_1(void * jarg1) {
53668   void * jresult ;
53669   Dali::Window *arg1 = 0 ;
53670   Dali::Window *result = 0 ;
53671
53672   arg1 = (Dali::Window *)jarg1;
53673   if (!arg1) {
53674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
53675     return 0;
53676   }
53677   {
53678     try {
53679       result = (Dali::Window *)new Dali::Window((Dali::Window const &)*arg1);
53680     } catch (std::out_of_range& e) {
53681       {
53682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53683       };
53684     } catch (std::exception& e) {
53685       {
53686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53687       };
53688     } catch (...) {
53689       {
53690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53691       };
53692     }
53693   }
53694   jresult = (void *)result;
53695   return jresult;
53696 }
53697
53698
53699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Assign(void * jarg1, void * jarg2) {
53700   void * jresult ;
53701   Dali::Window *arg1 = (Dali::Window *) 0 ;
53702   Dali::Window *arg2 = 0 ;
53703   Dali::Window *result = 0 ;
53704
53705   arg1 = (Dali::Window *)jarg1;
53706   arg2 = (Dali::Window *)jarg2;
53707   if (!arg2) {
53708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
53709     return 0;
53710   }
53711   {
53712     try {
53713       result = (Dali::Window *) &(arg1)->operator =((Dali::Window const &)*arg2);
53714     } catch (std::out_of_range& e) {
53715       {
53716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53717       };
53718     } catch (std::exception& e) {
53719       {
53720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53721       };
53722     } catch (...) {
53723       {
53724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53725       };
53726     }
53727   }
53728   jresult = (void *)result;
53729   return jresult;
53730 }
53731
53732
53733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_ShowIndicator(void * jarg1, int jarg2) {
53734   Dali::Window *arg1 = (Dali::Window *) 0 ;
53735   Dali::Window::IndicatorVisibleMode arg2 ;
53736
53737   arg1 = (Dali::Window *)jarg1;
53738   arg2 = (Dali::Window::IndicatorVisibleMode)jarg2;
53739   {
53740     try {
53741       (arg1)->ShowIndicator(arg2);
53742     } catch (std::out_of_range& e) {
53743       {
53744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53745       };
53746     } catch (std::exception& e) {
53747       {
53748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53749       };
53750     } catch (...) {
53751       {
53752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53753       };
53754     }
53755   }
53756 }
53757
53758
53759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetIndicatorBgOpacity(void * jarg1, int jarg2) {
53760   Dali::Window *arg1 = (Dali::Window *) 0 ;
53761   Dali::Window::IndicatorBgOpacity arg2 ;
53762
53763   arg1 = (Dali::Window *)jarg1;
53764   arg2 = (Dali::Window::IndicatorBgOpacity)jarg2;
53765   {
53766     try {
53767       (arg1)->SetIndicatorBgOpacity(arg2);
53768     } catch (std::out_of_range& e) {
53769       {
53770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53771       };
53772     } catch (std::exception& e) {
53773       {
53774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53775       };
53776     } catch (...) {
53777       {
53778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53779       };
53780     }
53781   }
53782 }
53783
53784
53785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RotateIndicator(void * jarg1, int jarg2) {
53786   Dali::Window *arg1 = (Dali::Window *) 0 ;
53787   Dali::Window::WindowOrientation arg2 ;
53788
53789   arg1 = (Dali::Window *)jarg1;
53790   arg2 = (Dali::Window::WindowOrientation)jarg2;
53791   {
53792     try {
53793       (arg1)->RotateIndicator(arg2);
53794     } catch (std::out_of_range& e) {
53795       {
53796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53797       };
53798     } catch (std::exception& e) {
53799       {
53800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53801       };
53802     } catch (...) {
53803       {
53804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53805       };
53806     }
53807   }
53808 }
53809
53810
53811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetClass(void * jarg1, char * jarg2, char * jarg3) {
53812   Dali::Window *arg1 = (Dali::Window *) 0 ;
53813   std::string arg2 ;
53814   std::string arg3 ;
53815
53816   arg1 = (Dali::Window *)jarg1;
53817   if (!jarg2) {
53818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53819     return ;
53820   }
53821   (&arg2)->assign(jarg2);
53822   if (!jarg3) {
53823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53824     return ;
53825   }
53826   (&arg3)->assign(jarg3);
53827   {
53828     try {
53829       (arg1)->SetClass(arg2,arg3);
53830     } catch (std::out_of_range& e) {
53831       {
53832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53833       };
53834     } catch (std::exception& e) {
53835       {
53836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53837       };
53838     } catch (...) {
53839       {
53840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53841       };
53842     }
53843   }
53844 }
53845
53846
53847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Raise(void * jarg1) {
53848   Dali::Window *arg1 = (Dali::Window *) 0 ;
53849
53850   arg1 = (Dali::Window *)jarg1;
53851   {
53852     try {
53853       (arg1)->Raise();
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_Window_Lower(void * jarg1) {
53872   Dali::Window *arg1 = (Dali::Window *) 0 ;
53873
53874   arg1 = (Dali::Window *)jarg1;
53875   {
53876     try {
53877       (arg1)->Lower();
53878     } catch (std::out_of_range& e) {
53879       {
53880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53881       };
53882     } catch (std::exception& e) {
53883       {
53884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53885       };
53886     } catch (...) {
53887       {
53888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53889       };
53890     }
53891   }
53892 }
53893
53894
53895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Activate(void * jarg1) {
53896   Dali::Window *arg1 = (Dali::Window *) 0 ;
53897
53898   arg1 = (Dali::Window *)jarg1;
53899   {
53900     try {
53901       (arg1)->Activate();
53902     } catch (std::out_of_range& e) {
53903       {
53904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53905       };
53906     } catch (std::exception& e) {
53907       {
53908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53909       };
53910     } catch (...) {
53911       {
53912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53913       };
53914     }
53915   }
53916 }
53917
53918
53919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_AddAvailableOrientation(void * jarg1, int jarg2) {
53920   Dali::Window *arg1 = (Dali::Window *) 0 ;
53921   Dali::Window::WindowOrientation arg2 ;
53922
53923   arg1 = (Dali::Window *)jarg1;
53924   arg2 = (Dali::Window::WindowOrientation)jarg2;
53925   {
53926     try {
53927       (arg1)->AddAvailableOrientation(arg2);
53928     } catch (std::out_of_range& e) {
53929       {
53930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53931       };
53932     } catch (std::exception& e) {
53933       {
53934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53935       };
53936     } catch (...) {
53937       {
53938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53939       };
53940     }
53941   }
53942 }
53943
53944
53945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RemoveAvailableOrientation(void * jarg1, int jarg2) {
53946   Dali::Window *arg1 = (Dali::Window *) 0 ;
53947   Dali::Window::WindowOrientation arg2 ;
53948
53949   arg1 = (Dali::Window *)jarg1;
53950   arg2 = (Dali::Window::WindowOrientation)jarg2;
53951   {
53952     try {
53953       (arg1)->RemoveAvailableOrientation(arg2);
53954     } catch (std::out_of_range& e) {
53955       {
53956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53957       };
53958     } catch (std::exception& e) {
53959       {
53960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53961       };
53962     } catch (...) {
53963       {
53964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53965       };
53966     }
53967   }
53968 }
53969
53970
53971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPreferredOrientation(void * jarg1, int jarg2) {
53972   Dali::Window *arg1 = (Dali::Window *) 0 ;
53973   Dali::Window::WindowOrientation arg2 ;
53974
53975   arg1 = (Dali::Window *)jarg1;
53976   arg2 = (Dali::Window::WindowOrientation)jarg2;
53977   {
53978     try {
53979       (arg1)->SetPreferredOrientation(arg2);
53980     } catch (std::out_of_range& e) {
53981       {
53982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53983       };
53984     } catch (std::exception& e) {
53985       {
53986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53987       };
53988     } catch (...) {
53989       {
53990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53991       };
53992     }
53993   }
53994 }
53995
53996
53997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Window_GetPreferredOrientation(void * jarg1) {
53998   int jresult ;
53999   Dali::Window *arg1 = (Dali::Window *) 0 ;
54000   Dali::Window::WindowOrientation result;
54001
54002   arg1 = (Dali::Window *)jarg1;
54003   {
54004     try {
54005       result = (Dali::Window::WindowOrientation)(arg1)->GetPreferredOrientation();
54006     } catch (std::out_of_range& e) {
54007       {
54008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54009       };
54010     } catch (std::exception& e) {
54011       {
54012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54013       };
54014     } catch (...) {
54015       {
54016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54017       };
54018     }
54019   }
54020   jresult = (int)result;
54021   return jresult;
54022 }
54023
54024
54025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetDragAndDropDetector(void * jarg1) {
54026   void * jresult ;
54027   Dali::Window *arg1 = (Dali::Window *) 0 ;
54028   Dali::DragAndDropDetector result;
54029
54030   arg1 = (Dali::Window *)jarg1;
54031   {
54032     try {
54033       result = ((Dali::Window const *)arg1)->GetDragAndDropDetector();
54034     } catch (std::out_of_range& e) {
54035       {
54036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54037       };
54038     } catch (std::exception& e) {
54039       {
54040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54041       };
54042     } catch (...) {
54043       {
54044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54045       };
54046     }
54047   }
54048   jresult = new Dali::DragAndDropDetector((const Dali::DragAndDropDetector &)result);
54049   return jresult;
54050 }
54051
54052
54053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetNativeHandle(void * jarg1) {
54054   void * jresult ;
54055   Dali::Window *arg1 = (Dali::Window *) 0 ;
54056   Dali::Any result;
54057
54058   arg1 = (Dali::Window *)jarg1;
54059   {
54060     try {
54061       result = ((Dali::Window const *)arg1)->GetNativeHandle();
54062     } catch (std::out_of_range& e) {
54063       {
54064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54065       };
54066     } catch (std::exception& e) {
54067       {
54068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54069       };
54070     } catch (...) {
54071       {
54072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54073       };
54074     }
54075   }
54076   jresult = new Dali::Any((const Dali::Any &)result);
54077   return jresult;
54078 }
54079
54080
54081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FocusChangedSignal(void * jarg1) {
54082   void * jresult ;
54083   Dali::Window arg1 ;
54084   Dali::Window *argp1 ;
54085   Dali::DevelWindow::FocusSignalType *result = 0 ;
54086
54087   argp1 = (Dali::Window *)jarg1;
54088   if (!argp1) {
54089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54090     return 0;
54091   }
54092   arg1 = *argp1;
54093   {
54094     try {
54095       result = (Dali::DevelWindow::FocusSignalType *) &Dali::DevelWindow::FocusChangedSignal(arg1);
54096     } catch (std::out_of_range& e) {
54097       {
54098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54099       };
54100     } catch (std::exception& e) {
54101       {
54102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54103       };
54104     } catch (...) {
54105       {
54106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54107       };
54108     }
54109   }
54110   jresult = (void *)result;
54111   return jresult;
54112 }
54113
54114
54115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetAcceptFocus(void * jarg1, unsigned int jarg2) {
54116   Dali::Window arg1 ;
54117   bool arg2 ;
54118   Dali::Window *argp1 ;
54119
54120   argp1 = (Dali::Window *)jarg1;
54121   if (!argp1) {
54122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54123     return ;
54124   }
54125   arg1 = *argp1;
54126   arg2 = jarg2 ? true : false;
54127   {
54128     try {
54129       Dali::DevelWindow::SetAcceptFocus(arg1,arg2);
54130     } catch (std::out_of_range& e) {
54131       {
54132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54133       };
54134     } catch (std::exception& e) {
54135       {
54136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54137       };
54138     } catch (...) {
54139       {
54140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54141       };
54142     }
54143   }
54144 }
54145
54146
54147 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsFocusAcceptable(void * jarg1) {
54148   unsigned int jresult ;
54149   Dali::Window arg1 ;
54150   Dali::Window *argp1 ;
54151   bool result;
54152
54153   argp1 = (Dali::Window *)jarg1;
54154   if (!argp1) {
54155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54156     return 0;
54157   }
54158   arg1 = *argp1;
54159   {
54160     try {
54161       result = (bool)Dali::DevelWindow::IsFocusAcceptable(arg1);
54162     } catch (std::out_of_range& e) {
54163       {
54164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54165       };
54166     } catch (std::exception& e) {
54167       {
54168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54169       };
54170     } catch (...) {
54171       {
54172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54173       };
54174     }
54175   }
54176   jresult = result;
54177   return jresult;
54178 }
54179
54180
54181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Show(void * jarg1) {
54182   Dali::Window arg1 ;
54183   Dali::Window *argp1 ;
54184
54185   argp1 = (Dali::Window *)jarg1;
54186   if (!argp1) {
54187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54188     return ;
54189   }
54190   arg1 = *argp1;
54191   {
54192     try {
54193       Dali::DevelWindow::Show(arg1);
54194     } catch (std::out_of_range& e) {
54195       {
54196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54197       };
54198     } catch (std::exception& e) {
54199       {
54200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54201       };
54202     } catch (...) {
54203       {
54204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54205       };
54206     }
54207   }
54208 }
54209
54210
54211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hide(void * jarg1) {
54212   Dali::Window arg1 ;
54213   Dali::Window *argp1 ;
54214
54215   argp1 = (Dali::Window *)jarg1;
54216   if (!argp1) {
54217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54218     return ;
54219   }
54220   arg1 = *argp1;
54221   {
54222     try {
54223       Dali::DevelWindow::Hide(arg1);
54224     } catch (std::out_of_range& e) {
54225       {
54226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54227       };
54228     } catch (std::exception& e) {
54229       {
54230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54231       };
54232     } catch (...) {
54233       {
54234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54235       };
54236     }
54237   }
54238 }
54239
54240
54241 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVisible(void * jarg1) {
54242   unsigned int jresult ;
54243   Dali::Window arg1 ;
54244   Dali::Window *argp1 ;
54245   bool result;
54246
54247   argp1 = (Dali::Window *)jarg1;
54248   if (!argp1) {
54249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54250     return 0;
54251   }
54252   arg1 = *argp1;
54253   {
54254     try {
54255       result = (bool)Dali::DevelWindow::IsVisible(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 = result;
54271   return jresult;
54272 }
54273
54274
54275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_0() {
54276   void * jresult ;
54277   Dali::Application result;
54278
54279   {
54280     try {
54281       result = Dali::Application::New();
54282     } catch (std::out_of_range& e) {
54283       {
54284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54285       };
54286     } catch (std::exception& e) {
54287       {
54288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54289       };
54290     } catch (...) {
54291       {
54292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54293       };
54294     }
54295   }
54296   jresult = new Dali::Application((const Dali::Application &)result);
54297   return jresult;
54298 }
54299
54300
54301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_1(int jarg1) {
54302   void * jresult ;
54303   int *arg1 = (int *) 0 ;
54304   char ***arg2 ;
54305   Dali::Application result;
54306
54307   {
54308     // Todo generate argv data from the C# args
54309     char **array;         // two dimensional array
54310     int numStrings = 1;     // number of strings
54311     int stringLength = 30;      // max string length.
54312     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
54313     argV = array;
54314
54315     // allocate the string data
54316     for( int i=0; i < numStrings; i++)
54317     {
54318       array[i]=(char *)malloc( stringLength * sizeof(char *) );
54319     }
54320     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
54321
54322     strcpy( array[0], "dali-csharp-app");
54323
54324     arg1 = &argC;
54325     arg2 = &argV;
54326   }
54327   {
54328     try {
54329       result = Dali::Application::New(arg1,arg2);
54330     } catch (std::out_of_range& e) {
54331       {
54332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54333       };
54334     } catch (std::exception& e) {
54335       {
54336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54337       };
54338     } catch (...) {
54339       {
54340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54341       };
54342     }
54343   }
54344   jresult = new Dali::Application((const Dali::Application &)result);
54345   return jresult;
54346 }
54347
54348
54349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_2(int jarg1, char * jarg3) {
54350   void * jresult ;
54351   int *arg1 = (int *) 0 ;
54352   char ***arg2 ;
54353   std::string *arg3 = 0 ;
54354   Dali::Application result;
54355
54356   {
54357     // Todo generate argv data from the C# args
54358     char **array;         // two dimensional array
54359     int numStrings = 1;     // number of strings
54360     int stringLength = 30;      // max string length.
54361     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
54362     argV = array;
54363
54364     // allocate the string data
54365     for( int i=0; i < numStrings; i++)
54366     {
54367       array[i]=(char *)malloc( stringLength * sizeof(char *) );
54368     }
54369     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
54370
54371     strcpy( array[0], "dali-csharp-app");
54372
54373     arg1 = &argC;
54374     arg2 = &argV;
54375   }
54376   if (!jarg3) {
54377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54378     return 0;
54379   }
54380   std::string arg3_str(jarg3);
54381   arg3 = &arg3_str;
54382   {
54383     try {
54384       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3);
54385     } catch (std::out_of_range& e) {
54386       {
54387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54388       };
54389     } catch (std::exception& e) {
54390       {
54391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54392       };
54393     } catch (...) {
54394       {
54395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54396       };
54397     }
54398   }
54399   jresult = new Dali::Application((const Dali::Application &)result);
54400
54401   //argout typemap for const std::string&
54402
54403   return jresult;
54404 }
54405
54406
54407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_3(int jarg1, char * jarg3, int jarg4) {
54408   void * jresult ;
54409   int *arg1 = (int *) 0 ;
54410   char ***arg2 ;
54411   std::string *arg3 = 0 ;
54412   Dali::Application::WINDOW_MODE arg4 ;
54413   Dali::Application result;
54414
54415   {
54416     // Todo generate argv data from the C# args
54417     char **array;         // two dimensional array
54418     int numStrings = 1;     // number of strings
54419     int stringLength = 30;      // max string length.
54420     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
54421     argV = array;
54422
54423     // allocate the string data
54424     for( int i=0; i < numStrings; i++)
54425     {
54426       array[i]=(char *)malloc( stringLength * sizeof(char *) );
54427     }
54428     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
54429
54430     strcpy( array[0], "dali-csharp-app");
54431
54432     arg1 = &argC;
54433     arg2 = &argV;
54434   }
54435   if (!jarg3) {
54436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54437     return 0;
54438   }
54439   std::string arg3_str(jarg3);
54440   arg3 = &arg3_str;
54441   arg4 = (Dali::Application::WINDOW_MODE)jarg4;
54442   {
54443     try {
54444       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3,arg4);
54445     } catch (std::out_of_range& e) {
54446       {
54447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54448       };
54449     } catch (std::exception& e) {
54450       {
54451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54452       };
54453     } catch (...) {
54454       {
54455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54456       };
54457     }
54458   }
54459   jresult = new Dali::Application((const Dali::Application &)result);
54460
54461   //argout typemap for const std::string&
54462
54463   return jresult;
54464 }
54465
54466
54467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_0() {
54468   void * jresult ;
54469   Dali::Application *result = 0 ;
54470
54471   {
54472     try {
54473       result = (Dali::Application *)new Dali::Application();
54474     } catch (std::out_of_range& e) {
54475       {
54476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54477       };
54478     } catch (std::exception& e) {
54479       {
54480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54481       };
54482     } catch (...) {
54483       {
54484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54485       };
54486     }
54487   }
54488   jresult = (void *)result;
54489   return jresult;
54490 }
54491
54492
54493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_1(void * jarg1) {
54494   void * jresult ;
54495   Dali::Application *arg1 = 0 ;
54496   Dali::Application *result = 0 ;
54497
54498   arg1 = (Dali::Application *)jarg1;
54499   if (!arg1) {
54500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
54501     return 0;
54502   }
54503   {
54504     try {
54505       result = (Dali::Application *)new Dali::Application((Dali::Application const &)*arg1);
54506     } catch (std::out_of_range& e) {
54507       {
54508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54509       };
54510     } catch (std::exception& e) {
54511       {
54512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54513       };
54514     } catch (...) {
54515       {
54516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54517       };
54518     }
54519   }
54520   jresult = (void *)result;
54521   return jresult;
54522 }
54523
54524
54525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_Assign(void * jarg1, void * jarg2) {
54526   void * jresult ;
54527   Dali::Application *arg1 = (Dali::Application *) 0 ;
54528   Dali::Application *arg2 = 0 ;
54529   Dali::Application *result = 0 ;
54530
54531   arg1 = (Dali::Application *)jarg1;
54532   arg2 = (Dali::Application *)jarg2;
54533   if (!arg2) {
54534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
54535     return 0;
54536   }
54537   {
54538     try {
54539       result = (Dali::Application *) &(arg1)->operator =((Dali::Application const &)*arg2);
54540     } catch (std::out_of_range& e) {
54541       {
54542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54543       };
54544     } catch (std::exception& e) {
54545       {
54546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54547       };
54548     } catch (...) {
54549       {
54550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54551       };
54552     }
54553   }
54554   jresult = (void *)result;
54555   return jresult;
54556 }
54557
54558
54559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Application(void * jarg1) {
54560   Dali::Application *arg1 = (Dali::Application *) 0 ;
54561
54562   arg1 = (Dali::Application *)jarg1;
54563   {
54564     try {
54565       delete arg1;
54566     } catch (std::out_of_range& e) {
54567       {
54568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54569       };
54570     } catch (std::exception& e) {
54571       {
54572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54573       };
54574     } catch (...) {
54575       {
54576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54577       };
54578     }
54579   }
54580 }
54581
54582
54583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_0(void * jarg1) {
54584   Dali::Application *arg1 = (Dali::Application *) 0 ;
54585
54586   arg1 = (Dali::Application *)jarg1;
54587   {
54588     try {
54589       (arg1)->MainLoop();
54590     } catch (std::out_of_range& e) {
54591       {
54592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54593       };
54594     } catch (std::exception& e) {
54595       {
54596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54597       };
54598     } catch (...) {
54599       {
54600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54601       };
54602     }
54603   }
54604 }
54605
54606
54607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_1(void * jarg1, void * jarg2) {
54608   Dali::Application *arg1 = (Dali::Application *) 0 ;
54609   Configuration::ContextLoss arg2 ;
54610   Configuration::ContextLoss *argp2 ;
54611
54612   arg1 = (Dali::Application *)jarg1;
54613   argp2 = (Configuration::ContextLoss *)jarg2;
54614   if (!argp2) {
54615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Configuration::ContextLoss", 0);
54616     return ;
54617   }
54618   arg2 = *argp2;
54619   {
54620     try {
54621       (arg1)->MainLoop(arg2);
54622     } catch (std::out_of_range& e) {
54623       {
54624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54625       };
54626     } catch (std::exception& e) {
54627       {
54628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54629       };
54630     } catch (...) {
54631       {
54632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54633       };
54634     }
54635   }
54636 }
54637
54638
54639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Lower(void * jarg1) {
54640   Dali::Application *arg1 = (Dali::Application *) 0 ;
54641
54642   arg1 = (Dali::Application *)jarg1;
54643   {
54644     try {
54645       (arg1)->Lower();
54646     } catch (std::out_of_range& e) {
54647       {
54648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54649       };
54650     } catch (std::exception& e) {
54651       {
54652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54653       };
54654     } catch (...) {
54655       {
54656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54657       };
54658     }
54659   }
54660 }
54661
54662
54663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Quit(void * jarg1) {
54664   Dali::Application *arg1 = (Dali::Application *) 0 ;
54665
54666   arg1 = (Dali::Application *)jarg1;
54667   {
54668     try {
54669       (arg1)->Quit();
54670     } catch (std::out_of_range& e) {
54671       {
54672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54673       };
54674     } catch (std::exception& e) {
54675       {
54676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54677       };
54678     } catch (...) {
54679       {
54680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54681       };
54682     }
54683   }
54684 }
54685
54686
54687 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_AddIdle(void * jarg1, void * jarg2) {
54688   unsigned int jresult ;
54689   Dali::Application *arg1 = (Dali::Application *) 0 ;
54690   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
54691   bool result;
54692
54693   arg1 = (Dali::Application *)jarg1;
54694   arg2 = (Dali::CallbackBase *)jarg2;
54695   {
54696     try {
54697       result = (bool)(arg1)->AddIdle(arg2);
54698     } catch (std::out_of_range& e) {
54699       {
54700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54701       };
54702     } catch (std::exception& e) {
54703       {
54704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54705       };
54706     } catch (...) {
54707       {
54708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54709       };
54710     }
54711   }
54712   jresult = result;
54713   return jresult;
54714 }
54715
54716
54717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_GetWindow(void * jarg1) {
54718   void * jresult ;
54719   Dali::Application *arg1 = (Dali::Application *) 0 ;
54720   Dali::Window result;
54721
54722   arg1 = (Dali::Application *)jarg1;
54723   {
54724     try {
54725       result = (arg1)->GetWindow();
54726     } catch (std::out_of_range& e) {
54727       {
54728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54729       };
54730     } catch (std::exception& e) {
54731       {
54732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54733       };
54734     } catch (...) {
54735       {
54736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54737       };
54738     }
54739   }
54740   jresult = new Dali::Window((const Dali::Window &)result);
54741   return jresult;
54742 }
54743
54744
54745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_ReplaceWindow(void * jarg1, void * jarg2, char * jarg3) {
54746   Dali::Application *arg1 = (Dali::Application *) 0 ;
54747   Dali::PositionSize arg2 ;
54748   std::string *arg3 = 0 ;
54749   Dali::PositionSize *argp2 ;
54750
54751   arg1 = (Dali::Application *)jarg1;
54752   argp2 = (Dali::PositionSize *)jarg2;
54753   if (!argp2) {
54754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
54755     return ;
54756   }
54757   arg2 = *argp2;
54758   if (!jarg3) {
54759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54760     return ;
54761   }
54762   std::string arg3_str(jarg3);
54763   arg3 = &arg3_str;
54764   {
54765     try {
54766       (arg1)->ReplaceWindow(arg2,(std::string const &)*arg3);
54767     } catch (std::out_of_range& e) {
54768       {
54769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54770       };
54771     } catch (std::exception& e) {
54772       {
54773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54774       };
54775     } catch (...) {
54776       {
54777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54778       };
54779     }
54780   }
54781
54782   //argout typemap for const std::string&
54783
54784 }
54785
54786
54787 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Application_GetResourcePath() {
54788   char * jresult ;
54789   std::string result;
54790
54791   {
54792     try {
54793       result = Dali::Application::GetResourcePath();
54794     } catch (std::out_of_range& e) {
54795       {
54796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54797       };
54798     } catch (std::exception& e) {
54799       {
54800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54801       };
54802     } catch (...) {
54803       {
54804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54805       };
54806     }
54807   }
54808   jresult = SWIG_csharp_string_callback((&result)->c_str());
54809   return jresult;
54810 }
54811
54812
54813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetViewMode(void * jarg1, int jarg2) {
54814   Dali::Application *arg1 = (Dali::Application *) 0 ;
54815   Dali::ViewMode arg2 ;
54816
54817   arg1 = (Dali::Application *)jarg1;
54818   arg2 = (Dali::ViewMode)jarg2;
54819   {
54820     try {
54821       (arg1)->SetViewMode(arg2);
54822     } catch (std::out_of_range& e) {
54823       {
54824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54825       };
54826     } catch (std::exception& e) {
54827       {
54828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54829       };
54830     } catch (...) {
54831       {
54832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54833       };
54834     }
54835   }
54836 }
54837
54838
54839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Application_GetViewMode(void * jarg1) {
54840   int jresult ;
54841   Dali::Application *arg1 = (Dali::Application *) 0 ;
54842   Dali::ViewMode result;
54843
54844   arg1 = (Dali::Application *)jarg1;
54845   {
54846     try {
54847       result = (Dali::ViewMode)((Dali::Application const *)arg1)->GetViewMode();
54848     } catch (std::out_of_range& e) {
54849       {
54850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54851       };
54852     } catch (std::exception& e) {
54853       {
54854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54855       };
54856     } catch (...) {
54857       {
54858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54859       };
54860     }
54861   }
54862   jresult = (int)result;
54863   return jresult;
54864 }
54865
54866
54867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetStereoBase(void * jarg1, float jarg2) {
54868   Dali::Application *arg1 = (Dali::Application *) 0 ;
54869   float arg2 ;
54870
54871   arg1 = (Dali::Application *)jarg1;
54872   arg2 = (float)jarg2;
54873   {
54874     try {
54875       (arg1)->SetStereoBase(arg2);
54876     } catch (std::out_of_range& e) {
54877       {
54878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54879       };
54880     } catch (std::exception& e) {
54881       {
54882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54883       };
54884     } catch (...) {
54885       {
54886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54887       };
54888     }
54889   }
54890 }
54891
54892
54893 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Application_GetStereoBase(void * jarg1) {
54894   float jresult ;
54895   Dali::Application *arg1 = (Dali::Application *) 0 ;
54896   float result;
54897
54898   arg1 = (Dali::Application *)jarg1;
54899   {
54900     try {
54901       result = (float)((Dali::Application const *)arg1)->GetStereoBase();
54902     } catch (std::out_of_range& e) {
54903       {
54904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54905       };
54906     } catch (std::exception& e) {
54907       {
54908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54909       };
54910     } catch (...) {
54911       {
54912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54913       };
54914     }
54915   }
54916   jresult = result;
54917   return jresult;
54918 }
54919
54920
54921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_InitSignal(void * jarg1) {
54922   void * jresult ;
54923   Dali::Application *arg1 = (Dali::Application *) 0 ;
54924   Dali::Application::AppSignalType *result = 0 ;
54925
54926   arg1 = (Dali::Application *)jarg1;
54927   {
54928     try {
54929       result = (Dali::Application::AppSignalType *) &(arg1)->InitSignal();
54930     } catch (std::out_of_range& e) {
54931       {
54932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54933       };
54934     } catch (std::exception& e) {
54935       {
54936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54937       };
54938     } catch (...) {
54939       {
54940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54941       };
54942     }
54943   }
54944   jresult = (void *)result;
54945   return jresult;
54946 }
54947
54948
54949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_TerminateSignal(void * jarg1) {
54950   void * jresult ;
54951   Dali::Application *arg1 = (Dali::Application *) 0 ;
54952   Dali::Application::AppSignalType *result = 0 ;
54953
54954   arg1 = (Dali::Application *)jarg1;
54955   {
54956     try {
54957       result = (Dali::Application::AppSignalType *) &(arg1)->TerminateSignal();
54958     } catch (std::out_of_range& e) {
54959       {
54960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54961       };
54962     } catch (std::exception& e) {
54963       {
54964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54965       };
54966     } catch (...) {
54967       {
54968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54969       };
54970     }
54971   }
54972   jresult = (void *)result;
54973   return jresult;
54974 }
54975
54976
54977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_PauseSignal(void * jarg1) {
54978   void * jresult ;
54979   Dali::Application *arg1 = (Dali::Application *) 0 ;
54980   Dali::Application::AppSignalType *result = 0 ;
54981
54982   arg1 = (Dali::Application *)jarg1;
54983   {
54984     try {
54985       result = (Dali::Application::AppSignalType *) &(arg1)->PauseSignal();
54986     } catch (std::out_of_range& e) {
54987       {
54988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54989       };
54990     } catch (std::exception& e) {
54991       {
54992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54993       };
54994     } catch (...) {
54995       {
54996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54997       };
54998     }
54999   }
55000   jresult = (void *)result;
55001   return jresult;
55002 }
55003
55004
55005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResumeSignal(void * jarg1) {
55006   void * jresult ;
55007   Dali::Application *arg1 = (Dali::Application *) 0 ;
55008   Dali::Application::AppSignalType *result = 0 ;
55009
55010   arg1 = (Dali::Application *)jarg1;
55011   {
55012     try {
55013       result = (Dali::Application::AppSignalType *) &(arg1)->ResumeSignal();
55014     } catch (std::out_of_range& e) {
55015       {
55016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55017       };
55018     } catch (std::exception& e) {
55019       {
55020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55021       };
55022     } catch (...) {
55023       {
55024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55025       };
55026     }
55027   }
55028   jresult = (void *)result;
55029   return jresult;
55030 }
55031
55032
55033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResetSignal(void * jarg1) {
55034   void * jresult ;
55035   Dali::Application *arg1 = (Dali::Application *) 0 ;
55036   Dali::Application::AppSignalType *result = 0 ;
55037
55038   arg1 = (Dali::Application *)jarg1;
55039   {
55040     try {
55041       result = (Dali::Application::AppSignalType *) &(arg1)->ResetSignal();
55042     } catch (std::out_of_range& e) {
55043       {
55044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55045       };
55046     } catch (std::exception& e) {
55047       {
55048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55049       };
55050     } catch (...) {
55051       {
55052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55053       };
55054     }
55055   }
55056   jresult = (void *)result;
55057   return jresult;
55058 }
55059
55060
55061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResizeSignal(void * jarg1) {
55062   void * jresult ;
55063   Dali::Application *arg1 = (Dali::Application *) 0 ;
55064   Dali::Application::AppSignalType *result = 0 ;
55065
55066   arg1 = (Dali::Application *)jarg1;
55067   {
55068     try {
55069       result = (Dali::Application::AppSignalType *) &(arg1)->ResizeSignal();
55070     } catch (std::out_of_range& e) {
55071       {
55072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55073       };
55074     } catch (std::exception& e) {
55075       {
55076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55077       };
55078     } catch (...) {
55079       {
55080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55081       };
55082     }
55083   }
55084   jresult = (void *)result;
55085   return jresult;
55086 }
55087
55088
55089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_AppControlSignal(void * jarg1) {
55090   void * jresult ;
55091   Dali::Application *arg1 = (Dali::Application *) 0 ;
55092   Dali::Application::AppControlSignalType *result = 0 ;
55093
55094   arg1 = (Dali::Application *)jarg1;
55095   {
55096     try {
55097       result = (Dali::Application::AppControlSignalType *) &(arg1)->AppControlSignal();
55098     } catch (std::out_of_range& e) {
55099       {
55100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55101       };
55102     } catch (std::exception& e) {
55103       {
55104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55105       };
55106     } catch (...) {
55107       {
55108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55109       };
55110     }
55111   }
55112   jresult = (void *)result;
55113   return jresult;
55114 }
55115
55116
55117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_LanguageChangedSignal(void * jarg1) {
55118   void * jresult ;
55119   Dali::Application *arg1 = (Dali::Application *) 0 ;
55120   Dali::Application::AppSignalType *result = 0 ;
55121
55122   arg1 = (Dali::Application *)jarg1;
55123   {
55124     try {
55125       result = (Dali::Application::AppSignalType *) &(arg1)->LanguageChangedSignal();
55126     } catch (std::out_of_range& e) {
55127       {
55128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55129       };
55130     } catch (std::exception& e) {
55131       {
55132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55133       };
55134     } catch (...) {
55135       {
55136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55137       };
55138     }
55139   }
55140   jresult = (void *)result;
55141   return jresult;
55142 }
55143
55144
55145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_RegionChangedSignal(void * jarg1) {
55146   void * jresult ;
55147   Dali::Application *arg1 = (Dali::Application *) 0 ;
55148   Dali::Application::AppSignalType *result = 0 ;
55149
55150   arg1 = (Dali::Application *)jarg1;
55151   {
55152     try {
55153       result = (Dali::Application::AppSignalType *) &(arg1)->RegionChangedSignal();
55154     } catch (std::out_of_range& e) {
55155       {
55156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55157       };
55158     } catch (std::exception& e) {
55159       {
55160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55161       };
55162     } catch (...) {
55163       {
55164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55165       };
55166     }
55167   }
55168   jresult = (void *)result;
55169   return jresult;
55170 }
55171
55172
55173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_BatteryLowSignal(void * jarg1) {
55174   void * jresult ;
55175   Dali::Application *arg1 = (Dali::Application *) 0 ;
55176   Dali::Application::AppSignalType *result = 0 ;
55177
55178   arg1 = (Dali::Application *)jarg1;
55179   {
55180     try {
55181       result = (Dali::Application::AppSignalType *) &(arg1)->BatteryLowSignal();
55182     } catch (std::out_of_range& e) {
55183       {
55184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55185       };
55186     } catch (std::exception& e) {
55187       {
55188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55189       };
55190     } catch (...) {
55191       {
55192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55193       };
55194     }
55195   }
55196   jresult = (void *)result;
55197   return jresult;
55198 }
55199
55200
55201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_MemoryLowSignal(void * jarg1) {
55202   void * jresult ;
55203   Dali::Application *arg1 = (Dali::Application *) 0 ;
55204   Dali::Application::AppSignalType *result = 0 ;
55205
55206   arg1 = (Dali::Application *)jarg1;
55207   {
55208     try {
55209       result = (Dali::Application::AppSignalType *) &(arg1)->MemoryLowSignal();
55210     } catch (std::out_of_range& e) {
55211       {
55212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55213       };
55214     } catch (std::exception& e) {
55215       {
55216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55217       };
55218     } catch (...) {
55219       {
55220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55221       };
55222     }
55223   }
55224   jresult = (void *)result;
55225   return jresult;
55226 }
55227
55228
55229 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationSignal_Empty(void * jarg1) {
55230   unsigned int jresult ;
55231   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55232   bool result;
55233
55234   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55235   {
55236     try {
55237       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Application &) > const *)arg1);
55238     } catch (std::out_of_range& e) {
55239       {
55240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55241       };
55242     } catch (std::exception& e) {
55243       {
55244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55245       };
55246     } catch (...) {
55247       {
55248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55249       };
55250     }
55251   }
55252   jresult = result;
55253   return jresult;
55254 }
55255
55256
55257 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationSignal_GetConnectionCount(void * jarg1) {
55258   unsigned long jresult ;
55259   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55260   std::size_t result;
55261
55262   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55263   {
55264     try {
55265       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &) > const *)arg1);
55266     } catch (std::out_of_range& e) {
55267       {
55268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55269       };
55270     } catch (std::exception& e) {
55271       {
55272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55273       };
55274     } catch (...) {
55275       {
55276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55277       };
55278     }
55279   }
55280   jresult = (unsigned long)result;
55281   return jresult;
55282 }
55283
55284
55285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Connect(void * jarg1, void * jarg2) {
55286   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55287   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
55288
55289   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55290   arg2 = (void (*)(Dali::Application &))jarg2;
55291   {
55292     try {
55293       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(arg1,arg2);
55294     } catch (std::out_of_range& e) {
55295       {
55296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55297       };
55298     } catch (std::exception& e) {
55299       {
55300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55301       };
55302     } catch (...) {
55303       {
55304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55305       };
55306     }
55307   }
55308 }
55309
55310
55311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Disconnect(void * jarg1, void * jarg2) {
55312   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55313   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
55314
55315   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55316   arg2 = (void (*)(Dali::Application &))jarg2;
55317   {
55318     try {
55319       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(arg1,arg2);
55320     } catch (std::out_of_range& e) {
55321       {
55322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55323       };
55324     } catch (std::exception& e) {
55325       {
55326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55327       };
55328     } catch (...) {
55329       {
55330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55331       };
55332     }
55333   }
55334 }
55335
55336
55337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Emit(void * jarg1, void * jarg2) {
55338   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55339   Dali::Application *arg2 = 0 ;
55340
55341   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55342   arg2 = (Dali::Application *)jarg2;
55343   if (!arg2) {
55344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
55345     return ;
55346   }
55347   {
55348     try {
55349       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(arg1,*arg2);
55350     } catch (std::out_of_range& e) {
55351       {
55352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55353       };
55354     } catch (std::exception& e) {
55355       {
55356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55357       };
55358     } catch (...) {
55359       {
55360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55361       };
55362     }
55363   }
55364 }
55365
55366
55367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationSignal() {
55368   void * jresult ;
55369   Dali::Signal< void (Dali::Application &) > *result = 0 ;
55370
55371   {
55372     try {
55373       result = (Dali::Signal< void (Dali::Application &) > *)new Dali::Signal< void (Dali::Application &) >();
55374     } catch (std::out_of_range& e) {
55375       {
55376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55377       };
55378     } catch (std::exception& e) {
55379       {
55380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55381       };
55382     } catch (...) {
55383       {
55384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55385       };
55386     }
55387   }
55388   jresult = (void *)result;
55389   return jresult;
55390 }
55391
55392
55393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationSignal(void * jarg1) {
55394   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55395
55396   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55397   {
55398     try {
55399       delete arg1;
55400     } catch (std::out_of_range& e) {
55401       {
55402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55403       };
55404     } catch (std::exception& e) {
55405       {
55406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55407       };
55408     } catch (...) {
55409       {
55410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55411       };
55412     }
55413   }
55414 }
55415
55416
55417 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Empty(void * jarg1) {
55418   unsigned int jresult ;
55419   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55420   bool result;
55421
55422   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55423   {
55424     try {
55425       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
55426     } catch (std::out_of_range& e) {
55427       {
55428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55429       };
55430     } catch (std::exception& e) {
55431       {
55432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55433       };
55434     } catch (...) {
55435       {
55436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55437       };
55438     }
55439   }
55440   jresult = result;
55441   return jresult;
55442 }
55443
55444
55445 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_GetConnectionCount(void * jarg1) {
55446   unsigned long jresult ;
55447   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55448   std::size_t result;
55449
55450   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55451   {
55452     try {
55453       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
55454     } catch (std::out_of_range& e) {
55455       {
55456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55457       };
55458     } catch (std::exception& e) {
55459       {
55460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55461       };
55462     } catch (...) {
55463       {
55464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55465       };
55466     }
55467   }
55468   jresult = (unsigned long)result;
55469   return jresult;
55470 }
55471
55472
55473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Connect(void * jarg1, void * jarg2) {
55474   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55475   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
55476
55477   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55478   arg2 = (void (*)(Dali::Application &,void *))jarg2;
55479   {
55480     try {
55481       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(arg1,arg2);
55482     } catch (std::out_of_range& e) {
55483       {
55484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55485       };
55486     } catch (std::exception& e) {
55487       {
55488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55489       };
55490     } catch (...) {
55491       {
55492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55493       };
55494     }
55495   }
55496 }
55497
55498
55499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Disconnect(void * jarg1, void * jarg2) {
55500   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55501   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
55502
55503   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55504   arg2 = (void (*)(Dali::Application &,void *))jarg2;
55505   {
55506     try {
55507       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(arg1,arg2);
55508     } catch (std::out_of_range& e) {
55509       {
55510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55511       };
55512     } catch (std::exception& e) {
55513       {
55514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55515       };
55516     } catch (...) {
55517       {
55518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55519       };
55520     }
55521   }
55522 }
55523
55524
55525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55526   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55527   Dali::Application *arg2 = 0 ;
55528   void *arg3 = (void *) 0 ;
55529
55530   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55531   arg2 = (Dali::Application *)jarg2;
55532   if (!arg2) {
55533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
55534     return ;
55535   }
55536   arg3 = jarg3;
55537   {
55538     try {
55539       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(arg1,*arg2,arg3);
55540     } catch (std::out_of_range& e) {
55541       {
55542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55543       };
55544     } catch (std::exception& e) {
55545       {
55546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55547       };
55548     } catch (...) {
55549       {
55550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55551       };
55552     }
55553   }
55554 }
55555
55556
55557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationControlSignal() {
55558   void * jresult ;
55559   Dali::Signal< void (Dali::Application &,void *) > *result = 0 ;
55560
55561   {
55562     try {
55563       result = (Dali::Signal< void (Dali::Application &,void *) > *)new Dali::Signal< void (Dali::Application &,void *) >();
55564     } catch (std::out_of_range& e) {
55565       {
55566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55567       };
55568     } catch (std::exception& e) {
55569       {
55570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55571       };
55572     } catch (...) {
55573       {
55574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55575       };
55576     }
55577   }
55578   jresult = (void *)result;
55579   return jresult;
55580 }
55581
55582
55583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationControlSignal(void * jarg1) {
55584   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55585
55586   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55587   {
55588     try {
55589       delete arg1;
55590     } catch (std::out_of_range& e) {
55591       {
55592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55593       };
55594     } catch (std::exception& e) {
55595       {
55596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55597       };
55598     } catch (...) {
55599       {
55600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55601       };
55602     }
55603   }
55604 }
55605
55606
55607 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
55608   unsigned int jresult ;
55609   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55610   bool result;
55611
55612   arg1 = (Dali::Signal< bool () > *)jarg1;
55613   {
55614     try {
55615       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
55616     } catch (std::out_of_range& e) {
55617       {
55618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55619       };
55620     } catch (std::exception& e) {
55621       {
55622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55623       };
55624     } catch (...) {
55625       {
55626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55627       };
55628     }
55629   }
55630   jresult = result;
55631   return jresult;
55632 }
55633
55634
55635 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
55636   unsigned long jresult ;
55637   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55638   std::size_t result;
55639
55640   arg1 = (Dali::Signal< bool () > *)jarg1;
55641   {
55642     try {
55643       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
55644     } catch (std::out_of_range& e) {
55645       {
55646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55647       };
55648     } catch (std::exception& e) {
55649       {
55650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55651       };
55652     } catch (...) {
55653       {
55654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55655       };
55656     }
55657   }
55658   jresult = (unsigned long)result;
55659   return jresult;
55660 }
55661
55662
55663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
55664   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55665   bool (*arg2)() = (bool (*)()) 0 ;
55666
55667   arg1 = (Dali::Signal< bool () > *)jarg1;
55668   arg2 = (bool (*)())jarg2;
55669   {
55670     try {
55671       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
55672     } catch (std::out_of_range& e) {
55673       {
55674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55675       };
55676     } catch (std::exception& e) {
55677       {
55678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55679       };
55680     } catch (...) {
55681       {
55682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55683       };
55684     }
55685   }
55686 }
55687
55688
55689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
55690   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55691   bool (*arg2)() = (bool (*)()) 0 ;
55692
55693   arg1 = (Dali::Signal< bool () > *)jarg1;
55694   arg2 = (bool (*)())jarg2;
55695   {
55696     try {
55697       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
55698     } catch (std::out_of_range& e) {
55699       {
55700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55701       };
55702     } catch (std::exception& e) {
55703       {
55704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55705       };
55706     } catch (...) {
55707       {
55708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55709       };
55710     }
55711   }
55712 }
55713
55714
55715 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
55716   unsigned int jresult ;
55717   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55718   bool result;
55719
55720   arg1 = (Dali::Signal< bool () > *)jarg1;
55721   {
55722     try {
55723       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
55724     } catch (std::out_of_range& e) {
55725       {
55726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55727       };
55728     } catch (std::exception& e) {
55729       {
55730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55731       };
55732     } catch (...) {
55733       {
55734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55735       };
55736     }
55737   }
55738   jresult = result;
55739   return jresult;
55740 }
55741
55742
55743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
55744   void * jresult ;
55745   Dali::Signal< bool () > *result = 0 ;
55746
55747   {
55748     try {
55749       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
55750     } catch (std::out_of_range& e) {
55751       {
55752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55753       };
55754     } catch (std::exception& e) {
55755       {
55756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55757       };
55758     } catch (...) {
55759       {
55760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55761       };
55762     }
55763   }
55764   jresult = (void *)result;
55765   return jresult;
55766 }
55767
55768
55769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
55770   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55771
55772   arg1 = (Dali::Signal< bool () > *)jarg1;
55773   {
55774     try {
55775       delete arg1;
55776     } catch (std::out_of_range& e) {
55777       {
55778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55779       };
55780     } catch (std::exception& e) {
55781       {
55782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55783       };
55784     } catch (...) {
55785       {
55786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55787       };
55788     }
55789   }
55790 }
55791
55792
55793
55794
55795
55796 //manual merge 2017-03-31
55797 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Empty(void * jarg1) {
55798   unsigned int jresult ;
55799   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55800   bool result;
55801
55802   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55803   {
55804     try {
55805       result = (bool)Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty((Dali::Signal< void (bool) > const *)arg1);
55806     } catch (std::out_of_range& e) {
55807       {
55808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55809       };
55810     } catch (std::exception& e) {
55811       {
55812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55813       };
55814     } catch (...) {
55815       {
55816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55817       };
55818     }
55819   }
55820   jresult = result;
55821   return jresult;
55822 }
55823
55824
55825 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_GetConnectionCount(void * jarg1) {
55826   unsigned long jresult ;
55827   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55828   std::size_t result;
55829
55830   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55831   {
55832     try {
55833       result = Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (bool) > const *)arg1);
55834     } catch (std::out_of_range& e) {
55835       {
55836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55837       };
55838     } catch (std::exception& e) {
55839       {
55840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55841       };
55842     } catch (...) {
55843       {
55844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55845       };
55846     }
55847   }
55848   jresult = (unsigned long)result;
55849   return jresult;
55850 }
55851
55852
55853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Connect(void * jarg1, void * jarg2) {
55854   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55855   void (*arg2)(bool) = (void (*)(bool)) 0 ;
55856
55857   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55858   arg2 = (void (*)(bool))jarg2;
55859   {
55860     try {
55861       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(arg1,arg2);
55862     } catch (std::out_of_range& e) {
55863       {
55864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55865       };
55866     } catch (std::exception& e) {
55867       {
55868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55869       };
55870     } catch (...) {
55871       {
55872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55873       };
55874     }
55875   }
55876 }
55877
55878
55879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Disconnect(void * jarg1, void * jarg2) {
55880   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55881   void (*arg2)(bool) = (void (*)(bool)) 0 ;
55882
55883   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55884   arg2 = (void (*)(bool))jarg2;
55885   {
55886     try {
55887       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(arg1,arg2);
55888     } catch (std::out_of_range& e) {
55889       {
55890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55891       };
55892     } catch (std::exception& e) {
55893       {
55894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55895       };
55896     } catch (...) {
55897       {
55898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55899       };
55900     }
55901   }
55902 }
55903
55904
55905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Emit(void * jarg1, unsigned int jarg2) {
55906   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55907   bool arg2 ;
55908
55909   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55910   arg2 = jarg2 ? true : false;
55911   {
55912     try {
55913       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(arg1,arg2);
55914     } catch (std::out_of_range& e) {
55915       {
55916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55917       };
55918     } catch (std::exception& e) {
55919       {
55920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55921       };
55922     } catch (...) {
55923       {
55924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55925       };
55926     }
55927   }
55928 }
55929
55930
55931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WindowFocusSignalType() {
55932   void * jresult ;
55933   Dali::Signal< void (bool) > *result = 0 ;
55934
55935   {
55936     try {
55937       result = (Dali::Signal< void (bool) > *)new Dali::Signal< void (bool) >();
55938     } catch (std::out_of_range& e) {
55939       {
55940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55941       };
55942     } catch (std::exception& e) {
55943       {
55944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55945       };
55946     } catch (...) {
55947       {
55948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55949       };
55950     }
55951   }
55952   jresult = (void *)result;
55953   return jresult;
55954 }
55955
55956
55957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WindowFocusSignalType(void * jarg1) {
55958   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55959
55960   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55961   {
55962     try {
55963       delete arg1;
55964     } catch (std::out_of_range& e) {
55965       {
55966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55967       };
55968     } catch (std::exception& e) {
55969       {
55970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55971       };
55972     } catch (...) {
55973       {
55974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55975       };
55976     }
55977   }
55978 }
55979
55980
55981
55982
55983
55984
55985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
55986   int jresult ;
55987   int result;
55988
55989   {
55990     try {
55991       result = (int)Dali::Toolkit::Visual::Property::TYPE;
55992     } catch (std::out_of_range& e) {
55993       {
55994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55995       };
55996     } catch (std::exception& e) {
55997       {
55998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55999       };
56000     } catch (...) {
56001       {
56002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56003       };
56004     }
56005   }
56006   jresult = (int)result;
56007   return jresult;
56008 }
56009
56010
56011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
56012   int jresult ;
56013   int result;
56014
56015   {
56016     try {
56017       result = (int)Dali::Toolkit::Visual::Property::SHADER;
56018     } catch (std::out_of_range& e) {
56019       {
56020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56021       };
56022     } catch (std::exception& e) {
56023       {
56024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56025       };
56026     } catch (...) {
56027       {
56028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56029       };
56030     }
56031   }
56032   jresult = (int)result;
56033   return jresult;
56034 }
56035
56036
56037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
56038   int jresult ;
56039   int result;
56040
56041   {
56042     try {
56043       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
56044     } catch (std::out_of_range& e) {
56045       {
56046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56047       };
56048     } catch (std::exception& e) {
56049       {
56050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56051       };
56052     } catch (...) {
56053       {
56054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56055       };
56056     }
56057   }
56058   jresult = (int)result;
56059   return jresult;
56060 }
56061
56062
56063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
56064   int jresult ;
56065   int result;
56066
56067   {
56068     try {
56069       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
56070     } catch (std::out_of_range& e) {
56071       {
56072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56073       };
56074     } catch (std::exception& e) {
56075       {
56076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56077       };
56078     } catch (...) {
56079       {
56080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56081       };
56082     }
56083   }
56084   jresult = (int)result;
56085   return jresult;
56086 }
56087
56088
56089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
56090   int jresult ;
56091   int result;
56092
56093   {
56094     try {
56095       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
56096     } catch (std::out_of_range& e) {
56097       {
56098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56099       };
56100     } catch (std::exception& e) {
56101       {
56102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56103       };
56104     } catch (...) {
56105       {
56106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56107       };
56108     }
56109   }
56110   jresult = (int)result;
56111   return jresult;
56112 }
56113
56114
56115 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
56116   int jresult ;
56117   int result;
56118
56119   {
56120     try {
56121       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
56122     } catch (std::out_of_range& e) {
56123       {
56124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56125       };
56126     } catch (std::exception& e) {
56127       {
56128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56129       };
56130     } catch (...) {
56131       {
56132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56133       };
56134     }
56135   }
56136   jresult = (int)result;
56137   return jresult;
56138 }
56139
56140
56141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
56142   int jresult ;
56143   int result;
56144
56145   {
56146     try {
56147       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
56148     } catch (std::out_of_range& e) {
56149       {
56150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56151       };
56152     } catch (std::exception& e) {
56153       {
56154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56155       };
56156     } catch (...) {
56157       {
56158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56159       };
56160     }
56161   }
56162   jresult = (int)result;
56163   return jresult;
56164 }
56165
56166
56167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
56168   int jresult ;
56169   int result;
56170
56171   {
56172     try {
56173       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
56174     } catch (std::out_of_range& e) {
56175       {
56176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56177       };
56178     } catch (std::exception& e) {
56179       {
56180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56181       };
56182     } catch (...) {
56183       {
56184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56185       };
56186     }
56187   }
56188   jresult = (int)result;
56189   return jresult;
56190 }
56191
56192
56193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
56194   int jresult ;
56195   int result;
56196
56197   {
56198     try {
56199       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
56200     } catch (std::out_of_range& e) {
56201       {
56202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56203       };
56204     } catch (std::exception& e) {
56205       {
56206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56207       };
56208     } catch (...) {
56209       {
56210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56211       };
56212     }
56213   }
56214   jresult = (int)result;
56215   return jresult;
56216 }
56217
56218
56219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
56220   int jresult ;
56221   int result;
56222
56223   {
56224     try {
56225       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
56226     } catch (std::out_of_range& e) {
56227       {
56228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56229       };
56230     } catch (std::exception& e) {
56231       {
56232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56233       };
56234     } catch (...) {
56235       {
56236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56237       };
56238     }
56239   }
56240   jresult = (int)result;
56241   return jresult;
56242 }
56243
56244
56245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
56246   int jresult ;
56247   int result;
56248
56249   {
56250     try {
56251       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
56252     } catch (std::out_of_range& e) {
56253       {
56254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56255       };
56256     } catch (std::exception& e) {
56257       {
56258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56259       };
56260     } catch (...) {
56261       {
56262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56263       };
56264     }
56265   }
56266   jresult = (int)result;
56267   return jresult;
56268 }
56269
56270
56271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
56272   int jresult ;
56273   int result;
56274
56275   {
56276     try {
56277       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
56278     } catch (std::out_of_range& e) {
56279       {
56280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56281       };
56282     } catch (std::exception& e) {
56283       {
56284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56285       };
56286     } catch (...) {
56287       {
56288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56289       };
56290     }
56291   }
56292   jresult = (int)result;
56293   return jresult;
56294 }
56295
56296
56297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
56298   int jresult ;
56299   int result;
56300
56301   {
56302     try {
56303       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
56304     } catch (std::out_of_range& e) {
56305       {
56306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56307       };
56308     } catch (std::exception& e) {
56309       {
56310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56311       };
56312     } catch (...) {
56313       {
56314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56315       };
56316     }
56317   }
56318   jresult = (int)result;
56319   return jresult;
56320 }
56321
56322
56323 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
56324   int jresult ;
56325   int result;
56326
56327   {
56328     try {
56329       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
56330     } catch (std::out_of_range& e) {
56331       {
56332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56333       };
56334     } catch (std::exception& e) {
56335       {
56336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56337       };
56338     } catch (...) {
56339       {
56340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56341       };
56342     }
56343   }
56344   jresult = (int)result;
56345   return jresult;
56346 }
56347
56348
56349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
56350   int jresult ;
56351   int result;
56352
56353   {
56354     try {
56355       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
56356     } catch (std::out_of_range& e) {
56357       {
56358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56359       };
56360     } catch (std::exception& e) {
56361       {
56362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56363       };
56364     } catch (...) {
56365       {
56366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56367       };
56368     }
56369   }
56370   jresult = (int)result;
56371   return jresult;
56372 }
56373
56374
56375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
56376   int jresult ;
56377   int result;
56378
56379   {
56380     try {
56381       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
56382     } catch (std::out_of_range& e) {
56383       {
56384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56385       };
56386     } catch (std::exception& e) {
56387       {
56388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56389       };
56390     } catch (...) {
56391       {
56392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56393       };
56394     }
56395   }
56396   jresult = (int)result;
56397   return jresult;
56398 }
56399
56400
56401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
56402   int jresult ;
56403   int result;
56404
56405   {
56406     try {
56407       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
56408     } catch (std::out_of_range& e) {
56409       {
56410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56411       };
56412     } catch (std::exception& e) {
56413       {
56414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56415       };
56416     } catch (...) {
56417       {
56418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56419       };
56420     }
56421   }
56422   jresult = (int)result;
56423   return jresult;
56424 }
56425
56426
56427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
56428   int jresult ;
56429   int result;
56430
56431   {
56432     try {
56433       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
56434     } catch (std::out_of_range& e) {
56435       {
56436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56437       };
56438     } catch (std::exception& e) {
56439       {
56440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56441       };
56442     } catch (...) {
56443       {
56444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56445       };
56446     }
56447   }
56448   jresult = (int)result;
56449   return jresult;
56450 }
56451
56452
56453 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
56454   int jresult ;
56455   int result;
56456
56457   {
56458     try {
56459       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
56460     } catch (std::out_of_range& e) {
56461       {
56462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56463       };
56464     } catch (std::exception& e) {
56465       {
56466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56467       };
56468     } catch (...) {
56469       {
56470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56471       };
56472     }
56473   }
56474   jresult = (int)result;
56475   return jresult;
56476 }
56477
56478
56479 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
56480   int jresult ;
56481   int result;
56482
56483   {
56484     try {
56485       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
56486     } catch (std::out_of_range& e) {
56487       {
56488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56489       };
56490     } catch (std::exception& e) {
56491       {
56492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56493       };
56494     } catch (...) {
56495       {
56496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56497       };
56498     }
56499   }
56500   jresult = (int)result;
56501   return jresult;
56502 }
56503
56504
56505 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
56506   int jresult ;
56507   int result;
56508
56509   {
56510     try {
56511       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
56512     } catch (std::out_of_range& e) {
56513       {
56514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56515       };
56516     } catch (std::exception& e) {
56517       {
56518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56519       };
56520     } catch (...) {
56521       {
56522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56523       };
56524     }
56525   }
56526   jresult = (int)result;
56527   return jresult;
56528 }
56529
56530
56531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
56532   int jresult ;
56533   int result;
56534
56535   {
56536     try {
56537       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
56538     } catch (std::out_of_range& e) {
56539       {
56540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56541       };
56542     } catch (std::exception& e) {
56543       {
56544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56545       };
56546     } catch (...) {
56547       {
56548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56549       };
56550     }
56551   }
56552   jresult = (int)result;
56553   return jresult;
56554 }
56555
56556
56557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
56558   int jresult ;
56559   int result;
56560
56561   {
56562     try {
56563       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
56564     } catch (std::out_of_range& e) {
56565       {
56566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56567       };
56568     } catch (std::exception& e) {
56569       {
56570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56571       };
56572     } catch (...) {
56573       {
56574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56575       };
56576     }
56577   }
56578   jresult = (int)result;
56579   return jresult;
56580 }
56581
56582
56583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
56584   int jresult ;
56585   int result;
56586
56587   {
56588     try {
56589       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
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 = (int)result;
56605   return jresult;
56606 }
56607
56608
56609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
56610   int jresult ;
56611   int result;
56612
56613   {
56614     try {
56615       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
56616     } catch (std::out_of_range& e) {
56617       {
56618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56619       };
56620     } catch (std::exception& e) {
56621       {
56622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56623       };
56624     } catch (...) {
56625       {
56626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56627       };
56628     }
56629   }
56630   jresult = (int)result;
56631   return jresult;
56632 }
56633
56634
56635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
56636   int jresult ;
56637   int result;
56638
56639   {
56640     try {
56641       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
56642     } catch (std::out_of_range& e) {
56643       {
56644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56645       };
56646     } catch (std::exception& e) {
56647       {
56648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56649       };
56650     } catch (...) {
56651       {
56652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56653       };
56654     }
56655   }
56656   jresult = (int)result;
56657   return jresult;
56658 }
56659
56660
56661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
56662   int jresult ;
56663   int result;
56664
56665   {
56666     try {
56667       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
56668     } catch (std::out_of_range& e) {
56669       {
56670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56671       };
56672     } catch (std::exception& e) {
56673       {
56674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56675       };
56676     } catch (...) {
56677       {
56678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56679       };
56680     }
56681   }
56682   jresult = (int)result;
56683   return jresult;
56684 }
56685
56686
56687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
56688   int jresult ;
56689   int result;
56690
56691   {
56692     try {
56693       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
56694     } catch (std::out_of_range& e) {
56695       {
56696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56697       };
56698     } catch (std::exception& e) {
56699       {
56700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56701       };
56702     } catch (...) {
56703       {
56704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56705       };
56706     }
56707   }
56708   jresult = (int)result;
56709   return jresult;
56710 }
56711
56712
56713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
56714   int jresult ;
56715   int result;
56716
56717   {
56718     try {
56719       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
56720     } catch (std::out_of_range& e) {
56721       {
56722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56723       };
56724     } catch (std::exception& e) {
56725       {
56726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56727       };
56728     } catch (...) {
56729       {
56730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56731       };
56732     }
56733   }
56734   jresult = (int)result;
56735   return jresult;
56736 }
56737
56738
56739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
56740   int jresult ;
56741   int result;
56742
56743   {
56744     try {
56745       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
56746     } catch (std::out_of_range& e) {
56747       {
56748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56749       };
56750     } catch (std::exception& e) {
56751       {
56752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56753       };
56754     } catch (...) {
56755       {
56756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56757       };
56758     }
56759   }
56760   jresult = (int)result;
56761   return jresult;
56762 }
56763
56764
56765 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
56766   int jresult ;
56767   int result;
56768
56769   {
56770     try {
56771       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
56772     } catch (std::out_of_range& e) {
56773       {
56774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56775       };
56776     } catch (std::exception& e) {
56777       {
56778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56779       };
56780     } catch (...) {
56781       {
56782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56783       };
56784     }
56785   }
56786   jresult = (int)result;
56787   return jresult;
56788 }
56789
56790
56791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
56792   int jresult ;
56793   int result;
56794
56795   {
56796     try {
56797       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
56798     } catch (std::out_of_range& e) {
56799       {
56800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56801       };
56802     } catch (std::exception& e) {
56803       {
56804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56805       };
56806     } catch (...) {
56807       {
56808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56809       };
56810     }
56811   }
56812   jresult = (int)result;
56813   return jresult;
56814 }
56815
56816
56817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
56818   int jresult ;
56819   int result;
56820
56821   {
56822     try {
56823       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
56824     } catch (std::out_of_range& e) {
56825       {
56826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56827       };
56828     } catch (std::exception& e) {
56829       {
56830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56831       };
56832     } catch (...) {
56833       {
56834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56835       };
56836     }
56837   }
56838   jresult = (int)result;
56839   return jresult;
56840 }
56841
56842
56843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
56844   int jresult ;
56845   int result;
56846
56847   {
56848     try {
56849       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
56850     } catch (std::out_of_range& e) {
56851       {
56852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56853       };
56854     } catch (std::exception& e) {
56855       {
56856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56857       };
56858     } catch (...) {
56859       {
56860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56861       };
56862     }
56863   }
56864   jresult = (int)result;
56865   return jresult;
56866 }
56867
56868
56869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
56870   int jresult ;
56871   int result;
56872
56873   {
56874     try {
56875       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
56876     } catch (std::out_of_range& e) {
56877       {
56878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56879       };
56880     } catch (std::exception& e) {
56881       {
56882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56883       };
56884     } catch (...) {
56885       {
56886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56887       };
56888     }
56889   }
56890   jresult = (int)result;
56891   return jresult;
56892 }
56893
56894
56895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
56896   int jresult ;
56897   int result;
56898
56899   {
56900     try {
56901       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
56902     } catch (std::out_of_range& e) {
56903       {
56904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56905       };
56906     } catch (std::exception& e) {
56907       {
56908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56909       };
56910     } catch (...) {
56911       {
56912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56913       };
56914     }
56915   }
56916   jresult = (int)result;
56917   return jresult;
56918 }
56919
56920
56921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
56922   int jresult ;
56923   int result;
56924
56925   {
56926     try {
56927       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
56928     } catch (std::out_of_range& e) {
56929       {
56930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56931       };
56932     } catch (std::exception& e) {
56933       {
56934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56935       };
56936     } catch (...) {
56937       {
56938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56939       };
56940     }
56941   }
56942   jresult = (int)result;
56943   return jresult;
56944 }
56945
56946
56947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
56948   int jresult ;
56949   int result;
56950
56951   {
56952     try {
56953       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
56954     } catch (std::out_of_range& e) {
56955       {
56956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56957       };
56958     } catch (std::exception& e) {
56959       {
56960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56961       };
56962     } catch (...) {
56963       {
56964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56965       };
56966     }
56967   }
56968   jresult = (int)result;
56969   return jresult;
56970 }
56971
56972
56973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
56974   int jresult ;
56975   int result;
56976
56977   {
56978     try {
56979       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
56980     } catch (std::out_of_range& e) {
56981       {
56982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56983       };
56984     } catch (std::exception& e) {
56985       {
56986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56987       };
56988     } catch (...) {
56989       {
56990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56991       };
56992     }
56993   }
56994   jresult = (int)result;
56995   return jresult;
56996 }
56997
56998
56999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
57000   int jresult ;
57001   int result;
57002
57003   {
57004     try {
57005       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
57006     } catch (std::out_of_range& e) {
57007       {
57008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57009       };
57010     } catch (std::exception& e) {
57011       {
57012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57013       };
57014     } catch (...) {
57015       {
57016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57017       };
57018     }
57019   }
57020   jresult = (int)result;
57021   return jresult;
57022 }
57023
57024
57025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
57026   int jresult ;
57027   int result;
57028
57029   {
57030     try {
57031       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
57032     } catch (std::out_of_range& e) {
57033       {
57034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57035       };
57036     } catch (std::exception& e) {
57037       {
57038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57039       };
57040     } catch (...) {
57041       {
57042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57043       };
57044     }
57045   }
57046   jresult = (int)result;
57047   return jresult;
57048 }
57049
57050
57051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
57052   int jresult ;
57053   int result;
57054
57055   {
57056     try {
57057       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
57058     } catch (std::out_of_range& e) {
57059       {
57060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57061       };
57062     } catch (std::exception& e) {
57063       {
57064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57065       };
57066     } catch (...) {
57067       {
57068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57069       };
57070     }
57071   }
57072   jresult = (int)result;
57073   return jresult;
57074 }
57075
57076
57077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
57078   int jresult ;
57079   int result;
57080
57081   {
57082     try {
57083       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
57084     } catch (std::out_of_range& e) {
57085       {
57086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57087       };
57088     } catch (std::exception& e) {
57089       {
57090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57091       };
57092     } catch (...) {
57093       {
57094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57095       };
57096     }
57097   }
57098   jresult = (int)result;
57099   return jresult;
57100 }
57101
57102
57103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
57104   int jresult ;
57105   int result;
57106
57107   {
57108     try {
57109       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
57110     } catch (std::out_of_range& e) {
57111       {
57112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57113       };
57114     } catch (std::exception& e) {
57115       {
57116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57117       };
57118     } catch (...) {
57119       {
57120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57121       };
57122     }
57123   }
57124   jresult = (int)result;
57125   return jresult;
57126 }
57127
57128
57129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
57130   int jresult ;
57131   int result;
57132
57133   {
57134     try {
57135       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
57136     } catch (std::out_of_range& e) {
57137       {
57138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57139       };
57140     } catch (std::exception& e) {
57141       {
57142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57143       };
57144     } catch (...) {
57145       {
57146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57147       };
57148     }
57149   }
57150   jresult = (int)result;
57151   return jresult;
57152 }
57153
57154
57155 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
57156   int jresult ;
57157   int result;
57158
57159   {
57160     try {
57161       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
57162     } catch (std::out_of_range& e) {
57163       {
57164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57165       };
57166     } catch (std::exception& e) {
57167       {
57168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57169       };
57170     } catch (...) {
57171       {
57172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57173       };
57174     }
57175   }
57176   jresult = (int)result;
57177   return jresult;
57178 }
57179
57180
57181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
57182   int jresult ;
57183   int result;
57184
57185   {
57186     try {
57187       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
57188     } catch (std::out_of_range& e) {
57189       {
57190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57191       };
57192     } catch (std::exception& e) {
57193       {
57194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57195       };
57196     } catch (...) {
57197       {
57198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57199       };
57200     }
57201   }
57202   jresult = (int)result;
57203   return jresult;
57204 }
57205
57206
57207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
57208   int jresult ;
57209   int result;
57210
57211   {
57212     try {
57213       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
57214     } catch (std::out_of_range& e) {
57215       {
57216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57217       };
57218     } catch (std::exception& e) {
57219       {
57220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57221       };
57222     } catch (...) {
57223       {
57224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57225       };
57226     }
57227   }
57228   jresult = (int)result;
57229   return jresult;
57230 }
57231
57232
57233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
57234   int jresult ;
57235   int result;
57236
57237   {
57238     try {
57239       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
57240     } catch (std::out_of_range& e) {
57241       {
57242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57243       };
57244     } catch (std::exception& e) {
57245       {
57246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57247       };
57248     } catch (...) {
57249       {
57250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57251       };
57252     }
57253   }
57254   jresult = (int)result;
57255   return jresult;
57256 }
57257
57258
57259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
57260   int jresult ;
57261   int result;
57262
57263   {
57264     try {
57265       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
57266     } catch (std::out_of_range& e) {
57267       {
57268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57269       };
57270     } catch (std::exception& e) {
57271       {
57272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57273       };
57274     } catch (...) {
57275       {
57276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57277       };
57278     }
57279   }
57280   jresult = (int)result;
57281   return jresult;
57282 }
57283
57284
57285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
57286   int jresult ;
57287   int result;
57288
57289   {
57290     try {
57291       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
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 = (int)result;
57307   return jresult;
57308 }
57309
57310
57311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
57312   int jresult ;
57313   int result;
57314
57315   {
57316     try {
57317       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
57318     } catch (std::out_of_range& e) {
57319       {
57320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57321       };
57322     } catch (std::exception& e) {
57323       {
57324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57325       };
57326     } catch (...) {
57327       {
57328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57329       };
57330     }
57331   }
57332   jresult = (int)result;
57333   return jresult;
57334 }
57335
57336
57337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
57338   int jresult ;
57339   int result;
57340
57341   {
57342     try {
57343       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
57344     } catch (std::out_of_range& e) {
57345       {
57346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57347       };
57348     } catch (std::exception& e) {
57349       {
57350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57351       };
57352     } catch (...) {
57353       {
57354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57355       };
57356     }
57357   }
57358   jresult = (int)result;
57359   return jresult;
57360 }
57361
57362
57363 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
57364   int jresult ;
57365   int result;
57366
57367   {
57368     try {
57369       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
57370     } catch (std::out_of_range& e) {
57371       {
57372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57373       };
57374     } catch (std::exception& e) {
57375       {
57376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57377       };
57378     } catch (...) {
57379       {
57380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57381       };
57382     }
57383   }
57384   jresult = (int)result;
57385   return jresult;
57386 }
57387
57388
57389 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
57390   int jresult ;
57391   int result;
57392
57393   {
57394     try {
57395       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
57396     } catch (std::out_of_range& e) {
57397       {
57398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57399       };
57400     } catch (std::exception& e) {
57401       {
57402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57403       };
57404     } catch (...) {
57405       {
57406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57407       };
57408     }
57409   }
57410   jresult = (int)result;
57411   return jresult;
57412 }
57413
57414
57415 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
57416   int jresult ;
57417   int result;
57418
57419   {
57420     try {
57421       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
57422     } catch (std::out_of_range& e) {
57423       {
57424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57425       };
57426     } catch (std::exception& e) {
57427       {
57428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57429       };
57430     } catch (...) {
57431       {
57432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57433       };
57434     }
57435   }
57436   jresult = (int)result;
57437   return jresult;
57438 }
57439
57440
57441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
57442   int jresult ;
57443   int result;
57444
57445   {
57446     try {
57447       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
57448     } catch (std::out_of_range& e) {
57449       {
57450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57451       };
57452     } catch (std::exception& e) {
57453       {
57454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57455       };
57456     } catch (...) {
57457       {
57458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57459       };
57460     }
57461   }
57462   jresult = (int)result;
57463   return jresult;
57464 }
57465
57466
57467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
57468   void * jresult ;
57469   Dali::Toolkit::Builder *result = 0 ;
57470
57471   {
57472     try {
57473       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
57474     } catch (std::out_of_range& e) {
57475       {
57476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57477       };
57478     } catch (std::exception& e) {
57479       {
57480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57481       };
57482     } catch (...) {
57483       {
57484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57485       };
57486     }
57487   }
57488   jresult = (void *)result;
57489   return jresult;
57490 }
57491
57492
57493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
57494   void * jresult ;
57495   Dali::Toolkit::Builder result;
57496
57497   {
57498     try {
57499       result = Dali::Toolkit::Builder::New();
57500     } catch (std::out_of_range& e) {
57501       {
57502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57503       };
57504     } catch (std::exception& e) {
57505       {
57506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57507       };
57508     } catch (...) {
57509       {
57510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57511       };
57512     }
57513   }
57514   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
57515   return jresult;
57516 }
57517
57518
57519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
57520   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57521
57522   arg1 = (Dali::Toolkit::Builder *)jarg1;
57523   {
57524     try {
57525       delete arg1;
57526     } catch (std::out_of_range& e) {
57527       {
57528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57529       };
57530     } catch (std::exception& e) {
57531       {
57532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57533       };
57534     } catch (...) {
57535       {
57536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57537       };
57538     }
57539   }
57540 }
57541
57542
57543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
57544   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57545   std::string *arg2 = 0 ;
57546   Dali::Toolkit::Builder::UIFormat arg3 ;
57547
57548   arg1 = (Dali::Toolkit::Builder *)jarg1;
57549   if (!jarg2) {
57550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57551     return ;
57552   }
57553   std::string arg2_str(jarg2);
57554   arg2 = &arg2_str;
57555   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
57556   {
57557     try {
57558       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
57559     } catch (std::out_of_range& e) {
57560       {
57561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57562       };
57563     } catch (std::exception& e) {
57564       {
57565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57566       };
57567     } catch (...) {
57568       {
57569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57570       };
57571     }
57572   }
57573
57574   //argout typemap for const std::string&
57575
57576 }
57577
57578
57579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
57580   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57581   std::string *arg2 = 0 ;
57582
57583   arg1 = (Dali::Toolkit::Builder *)jarg1;
57584   if (!jarg2) {
57585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57586     return ;
57587   }
57588   std::string arg2_str(jarg2);
57589   arg2 = &arg2_str;
57590   {
57591     try {
57592       (arg1)->LoadFromString((std::string const &)*arg2);
57593     } catch (std::out_of_range& e) {
57594       {
57595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57596       };
57597     } catch (std::exception& e) {
57598       {
57599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57600       };
57601     } catch (...) {
57602       {
57603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57604       };
57605     }
57606   }
57607
57608   //argout typemap for const std::string&
57609
57610 }
57611
57612
57613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
57614   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57615   Dali::Property::Map *arg2 = 0 ;
57616
57617   arg1 = (Dali::Toolkit::Builder *)jarg1;
57618   arg2 = (Dali::Property::Map *)jarg2;
57619   if (!arg2) {
57620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57621     return ;
57622   }
57623   {
57624     try {
57625       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
57626     } catch (std::out_of_range& e) {
57627       {
57628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57629       };
57630     } catch (std::exception& e) {
57631       {
57632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57633       };
57634     } catch (...) {
57635       {
57636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57637       };
57638     }
57639   }
57640 }
57641
57642
57643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
57644   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57645   std::string *arg2 = 0 ;
57646   Dali::Property::Value *arg3 = 0 ;
57647
57648   arg1 = (Dali::Toolkit::Builder *)jarg1;
57649   if (!jarg2) {
57650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57651     return ;
57652   }
57653   std::string arg2_str(jarg2);
57654   arg2 = &arg2_str;
57655   arg3 = (Dali::Property::Value *)jarg3;
57656   if (!arg3) {
57657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
57658     return ;
57659   }
57660   {
57661     try {
57662       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
57663     } catch (std::out_of_range& e) {
57664       {
57665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57666       };
57667     } catch (std::exception& e) {
57668       {
57669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57670       };
57671     } catch (...) {
57672       {
57673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57674       };
57675     }
57676   }
57677
57678   //argout typemap for const std::string&
57679
57680 }
57681
57682
57683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
57684   void * jresult ;
57685   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57686   Dali::Property::Map *result = 0 ;
57687
57688   arg1 = (Dali::Toolkit::Builder *)jarg1;
57689   {
57690     try {
57691       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
57692     } catch (std::out_of_range& e) {
57693       {
57694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57695       };
57696     } catch (std::exception& e) {
57697       {
57698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57699       };
57700     } catch (...) {
57701       {
57702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57703       };
57704     }
57705   }
57706   jresult = (void *)result;
57707   return jresult;
57708 }
57709
57710
57711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
57712   void * jresult ;
57713   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57714   std::string *arg2 = 0 ;
57715   Dali::Property::Value *result = 0 ;
57716
57717   arg1 = (Dali::Toolkit::Builder *)jarg1;
57718   if (!jarg2) {
57719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57720     return 0;
57721   }
57722   std::string arg2_str(jarg2);
57723   arg2 = &arg2_str;
57724   {
57725     try {
57726       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
57727     } catch (std::out_of_range& e) {
57728       {
57729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57730       };
57731     } catch (std::exception& e) {
57732       {
57733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57734       };
57735     } catch (...) {
57736       {
57737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57738       };
57739     }
57740   }
57741   jresult = (void *)result;
57742
57743   //argout typemap for const std::string&
57744
57745   return jresult;
57746 }
57747
57748
57749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
57750   void * jresult ;
57751   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57752   std::string *arg2 = 0 ;
57753   Dali::Animation result;
57754
57755   arg1 = (Dali::Toolkit::Builder *)jarg1;
57756   if (!jarg2) {
57757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57758     return 0;
57759   }
57760   std::string arg2_str(jarg2);
57761   arg2 = &arg2_str;
57762   {
57763     try {
57764       result = (arg1)->CreateAnimation((std::string const &)*arg2);
57765     } catch (std::out_of_range& e) {
57766       {
57767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57768       };
57769     } catch (std::exception& e) {
57770       {
57771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57772       };
57773     } catch (...) {
57774       {
57775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57776       };
57777     }
57778   }
57779   jresult = new Dali::Animation((const Dali::Animation &)result);
57780
57781   //argout typemap for const std::string&
57782
57783   return jresult;
57784 }
57785
57786
57787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57788   void * jresult ;
57789   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57790   std::string *arg2 = 0 ;
57791   Dali::Property::Map *arg3 = 0 ;
57792   Dali::Animation result;
57793
57794   arg1 = (Dali::Toolkit::Builder *)jarg1;
57795   if (!jarg2) {
57796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57797     return 0;
57798   }
57799   std::string arg2_str(jarg2);
57800   arg2 = &arg2_str;
57801   arg3 = (Dali::Property::Map *)jarg3;
57802   if (!arg3) {
57803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57804     return 0;
57805   }
57806   {
57807     try {
57808       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57809     } catch (std::out_of_range& e) {
57810       {
57811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57812       };
57813     } catch (std::exception& e) {
57814       {
57815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57816       };
57817     } catch (...) {
57818       {
57819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57820       };
57821     }
57822   }
57823   jresult = new Dali::Animation((const Dali::Animation &)result);
57824
57825   //argout typemap for const std::string&
57826
57827   return jresult;
57828 }
57829
57830
57831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
57832   void * jresult ;
57833   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57834   std::string *arg2 = 0 ;
57835   Dali::Actor arg3 ;
57836   Dali::Actor *argp3 ;
57837   Dali::Animation result;
57838
57839   arg1 = (Dali::Toolkit::Builder *)jarg1;
57840   if (!jarg2) {
57841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57842     return 0;
57843   }
57844   std::string arg2_str(jarg2);
57845   arg2 = &arg2_str;
57846   argp3 = (Dali::Actor *)jarg3;
57847   if (!argp3) {
57848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57849     return 0;
57850   }
57851   arg3 = *argp3;
57852   {
57853     try {
57854       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
57855     } catch (std::out_of_range& e) {
57856       {
57857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57858       };
57859     } catch (std::exception& e) {
57860       {
57861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57862       };
57863     } catch (...) {
57864       {
57865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57866       };
57867     }
57868   }
57869   jresult = new Dali::Animation((const Dali::Animation &)result);
57870
57871   //argout typemap for const std::string&
57872
57873   return jresult;
57874 }
57875
57876
57877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
57878   void * jresult ;
57879   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57880   std::string *arg2 = 0 ;
57881   Dali::Property::Map *arg3 = 0 ;
57882   Dali::Actor arg4 ;
57883   Dali::Actor *argp4 ;
57884   Dali::Animation result;
57885
57886   arg1 = (Dali::Toolkit::Builder *)jarg1;
57887   if (!jarg2) {
57888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57889     return 0;
57890   }
57891   std::string arg2_str(jarg2);
57892   arg2 = &arg2_str;
57893   arg3 = (Dali::Property::Map *)jarg3;
57894   if (!arg3) {
57895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57896     return 0;
57897   }
57898   argp4 = (Dali::Actor *)jarg4;
57899   if (!argp4) {
57900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57901     return 0;
57902   }
57903   arg4 = *argp4;
57904   {
57905     try {
57906       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
57907     } catch (std::out_of_range& e) {
57908       {
57909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57910       };
57911     } catch (std::exception& e) {
57912       {
57913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57914       };
57915     } catch (...) {
57916       {
57917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57918       };
57919     }
57920   }
57921   jresult = new Dali::Animation((const Dali::Animation &)result);
57922
57923   //argout typemap for const std::string&
57924
57925   return jresult;
57926 }
57927
57928
57929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
57930   void * jresult ;
57931   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57932   std::string *arg2 = 0 ;
57933   Dali::BaseHandle result;
57934
57935   arg1 = (Dali::Toolkit::Builder *)jarg1;
57936   if (!jarg2) {
57937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57938     return 0;
57939   }
57940   std::string arg2_str(jarg2);
57941   arg2 = &arg2_str;
57942   {
57943     try {
57944       result = (arg1)->Create((std::string const &)*arg2);
57945     } catch (std::out_of_range& e) {
57946       {
57947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57948       };
57949     } catch (std::exception& e) {
57950       {
57951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57952       };
57953     } catch (...) {
57954       {
57955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57956       };
57957     }
57958   }
57959   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57960
57961   //argout typemap for const std::string&
57962
57963   return jresult;
57964 }
57965
57966
57967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57968   void * jresult ;
57969   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57970   std::string *arg2 = 0 ;
57971   Dali::Property::Map *arg3 = 0 ;
57972   Dali::BaseHandle result;
57973
57974   arg1 = (Dali::Toolkit::Builder *)jarg1;
57975   if (!jarg2) {
57976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57977     return 0;
57978   }
57979   std::string arg2_str(jarg2);
57980   arg2 = &arg2_str;
57981   arg3 = (Dali::Property::Map *)jarg3;
57982   if (!arg3) {
57983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57984     return 0;
57985   }
57986   {
57987     try {
57988       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57989     } catch (std::out_of_range& e) {
57990       {
57991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57992       };
57993     } catch (std::exception& e) {
57994       {
57995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57996       };
57997     } catch (...) {
57998       {
57999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58000       };
58001     }
58002   }
58003   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58004
58005   //argout typemap for const std::string&
58006
58007   return jresult;
58008 }
58009
58010
58011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
58012   void * jresult ;
58013   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58014   std::string *arg2 = 0 ;
58015   Dali::BaseHandle result;
58016
58017   arg1 = (Dali::Toolkit::Builder *)jarg1;
58018   if (!jarg2) {
58019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58020     return 0;
58021   }
58022   std::string arg2_str(jarg2);
58023   arg2 = &arg2_str;
58024   {
58025     try {
58026       result = (arg1)->CreateFromJson((std::string const &)*arg2);
58027     } catch (std::out_of_range& e) {
58028       {
58029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58030       };
58031     } catch (std::exception& e) {
58032       {
58033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58034       };
58035     } catch (...) {
58036       {
58037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58038       };
58039     }
58040   }
58041   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58042
58043   //argout typemap for const std::string&
58044
58045   return jresult;
58046 }
58047
58048
58049 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
58050   unsigned int jresult ;
58051   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58052   std::string *arg2 = 0 ;
58053   Dali::Handle *arg3 = 0 ;
58054   bool result;
58055
58056   arg1 = (Dali::Toolkit::Builder *)jarg1;
58057   if (!jarg2) {
58058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58059     return 0;
58060   }
58061   std::string arg2_str(jarg2);
58062   arg2 = &arg2_str;
58063   arg3 = (Dali::Handle *)jarg3;
58064   if (!arg3) {
58065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58066     return 0;
58067   }
58068   {
58069     try {
58070       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
58071     } catch (std::out_of_range& e) {
58072       {
58073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58074       };
58075     } catch (std::exception& e) {
58076       {
58077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58078       };
58079     } catch (...) {
58080       {
58081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58082       };
58083     }
58084   }
58085   jresult = result;
58086
58087   //argout typemap for const std::string&
58088
58089   return jresult;
58090 }
58091
58092
58093 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
58094   unsigned int jresult ;
58095   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58096   Dali::Handle *arg2 = 0 ;
58097   std::string *arg3 = 0 ;
58098   bool result;
58099
58100   arg1 = (Dali::Toolkit::Builder *)jarg1;
58101   arg2 = (Dali::Handle *)jarg2;
58102   if (!arg2) {
58103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58104     return 0;
58105   }
58106   if (!jarg3) {
58107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58108     return 0;
58109   }
58110   std::string arg3_str(jarg3);
58111   arg3 = &arg3_str;
58112   {
58113     try {
58114       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
58115     } catch (std::out_of_range& e) {
58116       {
58117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58118       };
58119     } catch (std::exception& e) {
58120       {
58121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58122       };
58123     } catch (...) {
58124       {
58125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58126       };
58127     }
58128   }
58129   jresult = result;
58130
58131   //argout typemap for const std::string&
58132
58133   return jresult;
58134 }
58135
58136
58137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
58138   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58139   Dali::Actor arg2 ;
58140   Dali::Actor *argp2 ;
58141
58142   arg1 = (Dali::Toolkit::Builder *)jarg1;
58143   argp2 = (Dali::Actor *)jarg2;
58144   if (!argp2) {
58145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58146     return ;
58147   }
58148   arg2 = *argp2;
58149   {
58150     try {
58151       (arg1)->AddActors(arg2);
58152     } catch (std::out_of_range& e) {
58153       {
58154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58155       };
58156     } catch (std::exception& e) {
58157       {
58158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58159       };
58160     } catch (...) {
58161       {
58162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58163       };
58164     }
58165   }
58166 }
58167
58168
58169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58170   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58171   std::string *arg2 = 0 ;
58172   Dali::Actor arg3 ;
58173   Dali::Actor *argp3 ;
58174
58175   arg1 = (Dali::Toolkit::Builder *)jarg1;
58176   if (!jarg2) {
58177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58178     return ;
58179   }
58180   std::string arg2_str(jarg2);
58181   arg2 = &arg2_str;
58182   argp3 = (Dali::Actor *)jarg3;
58183   if (!argp3) {
58184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58185     return ;
58186   }
58187   arg3 = *argp3;
58188   {
58189     try {
58190       (arg1)->AddActors((std::string const &)*arg2,arg3);
58191     } catch (std::out_of_range& e) {
58192       {
58193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58194       };
58195     } catch (std::exception& e) {
58196       {
58197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58198       };
58199     } catch (...) {
58200       {
58201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58202       };
58203     }
58204   }
58205
58206   //argout typemap for const std::string&
58207
58208 }
58209
58210
58211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
58212   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58213   std::string *arg2 = 0 ;
58214
58215   arg1 = (Dali::Toolkit::Builder *)jarg1;
58216   if (!jarg2) {
58217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58218     return ;
58219   }
58220   std::string arg2_str(jarg2);
58221   arg2 = &arg2_str;
58222   {
58223     try {
58224       (arg1)->CreateRenderTask((std::string const &)*arg2);
58225     } catch (std::out_of_range& e) {
58226       {
58227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58228       };
58229     } catch (std::exception& e) {
58230       {
58231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58232       };
58233     } catch (...) {
58234       {
58235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58236       };
58237     }
58238   }
58239
58240   //argout typemap for const std::string&
58241
58242 }
58243
58244
58245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
58246   void * jresult ;
58247   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58248   std::string *arg2 = 0 ;
58249   Dali::FrameBufferImage result;
58250
58251   arg1 = (Dali::Toolkit::Builder *)jarg1;
58252   if (!jarg2) {
58253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58254     return 0;
58255   }
58256   std::string arg2_str(jarg2);
58257   arg2 = &arg2_str;
58258   {
58259     try {
58260       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
58261     } catch (std::out_of_range& e) {
58262       {
58263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58264       };
58265     } catch (std::exception& e) {
58266       {
58267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58268       };
58269     } catch (...) {
58270       {
58271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58272       };
58273     }
58274   }
58275   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
58276
58277   //argout typemap for const std::string&
58278
58279   return jresult;
58280 }
58281
58282
58283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
58284   void * jresult ;
58285   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58286   std::string *arg2 = 0 ;
58287   Dali::Path result;
58288
58289   arg1 = (Dali::Toolkit::Builder *)jarg1;
58290   if (!jarg2) {
58291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58292     return 0;
58293   }
58294   std::string arg2_str(jarg2);
58295   arg2 = &arg2_str;
58296   {
58297     try {
58298       result = (arg1)->GetPath((std::string const &)*arg2);
58299     } catch (std::out_of_range& e) {
58300       {
58301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58302       };
58303     } catch (std::exception& e) {
58304       {
58305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58306       };
58307     } catch (...) {
58308       {
58309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58310       };
58311     }
58312   }
58313   jresult = new Dali::Path((const Dali::Path &)result);
58314
58315   //argout typemap for const std::string&
58316
58317   return jresult;
58318 }
58319
58320
58321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
58322   void * jresult ;
58323   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58324   std::string *arg2 = 0 ;
58325   Dali::PathConstrainer result;
58326
58327   arg1 = (Dali::Toolkit::Builder *)jarg1;
58328   if (!jarg2) {
58329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58330     return 0;
58331   }
58332   std::string arg2_str(jarg2);
58333   arg2 = &arg2_str;
58334   {
58335     try {
58336       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
58337     } catch (std::out_of_range& e) {
58338       {
58339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58340       };
58341     } catch (std::exception& e) {
58342       {
58343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58344       };
58345     } catch (...) {
58346       {
58347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58348       };
58349     }
58350   }
58351   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
58352
58353   //argout typemap for const std::string&
58354
58355   return jresult;
58356 }
58357
58358
58359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
58360   void * jresult ;
58361   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58362   std::string *arg2 = 0 ;
58363   Dali::LinearConstrainer result;
58364
58365   arg1 = (Dali::Toolkit::Builder *)jarg1;
58366   if (!jarg2) {
58367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58368     return 0;
58369   }
58370   std::string arg2_str(jarg2);
58371   arg2 = &arg2_str;
58372   {
58373     try {
58374       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
58375     } catch (std::out_of_range& e) {
58376       {
58377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58378       };
58379     } catch (std::exception& e) {
58380       {
58381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58382       };
58383     } catch (...) {
58384       {
58385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58386       };
58387     }
58388   }
58389   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
58390
58391   //argout typemap for const std::string&
58392
58393   return jresult;
58394 }
58395
58396
58397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
58398   void * jresult ;
58399   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58400   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
58401
58402   arg1 = (Dali::Toolkit::Builder *)jarg1;
58403   {
58404     try {
58405       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
58406     } catch (std::out_of_range& e) {
58407       {
58408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58409       };
58410     } catch (std::exception& e) {
58411       {
58412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58413       };
58414     } catch (...) {
58415       {
58416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58417       };
58418     }
58419   }
58420   jresult = (void *)result;
58421   return jresult;
58422 }
58423
58424
58425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
58426   void * jresult ;
58427   Dali::Toolkit::TransitionData *result = 0 ;
58428
58429   {
58430     try {
58431       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
58432     } catch (std::out_of_range& e) {
58433       {
58434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58435       };
58436     } catch (std::exception& e) {
58437       {
58438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58439       };
58440     } catch (...) {
58441       {
58442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58443       };
58444     }
58445   }
58446   jresult = (void *)result;
58447   return jresult;
58448 }
58449
58450
58451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
58452   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58453
58454   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58455   {
58456     try {
58457       delete arg1;
58458     } catch (std::out_of_range& e) {
58459       {
58460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58461       };
58462     } catch (std::exception& e) {
58463       {
58464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58465       };
58466     } catch (...) {
58467       {
58468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58469       };
58470     }
58471   }
58472 }
58473
58474
58475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
58476   void * jresult ;
58477   Dali::Property::Map *arg1 = 0 ;
58478   Dali::Toolkit::TransitionData result;
58479
58480   arg1 = (Dali::Property::Map *)jarg1;
58481   if (!arg1) {
58482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58483     return 0;
58484   }
58485   {
58486     try {
58487       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
58488     } catch (std::out_of_range& e) {
58489       {
58490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58491       };
58492     } catch (std::exception& e) {
58493       {
58494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58495       };
58496     } catch (...) {
58497       {
58498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58499       };
58500     }
58501   }
58502   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58503   return jresult;
58504 }
58505
58506
58507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
58508   void * jresult ;
58509   Dali::Property::Array *arg1 = 0 ;
58510   Dali::Toolkit::TransitionData result;
58511
58512   arg1 = (Dali::Property::Array *)jarg1;
58513   if (!arg1) {
58514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
58515     return 0;
58516   }
58517   {
58518     try {
58519       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
58520     } catch (std::out_of_range& e) {
58521       {
58522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58523       };
58524     } catch (std::exception& e) {
58525       {
58526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58527       };
58528     } catch (...) {
58529       {
58530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58531       };
58532     }
58533   }
58534   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58535   return jresult;
58536 }
58537
58538
58539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
58540   void * jresult ;
58541   Dali::BaseHandle arg1 ;
58542   Dali::BaseHandle *argp1 ;
58543   Dali::Toolkit::TransitionData result;
58544
58545   argp1 = (Dali::BaseHandle *)jarg1;
58546   if (!argp1) {
58547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58548     return 0;
58549   }
58550   arg1 = *argp1;
58551   {
58552     try {
58553       result = Dali::Toolkit::TransitionData::DownCast(arg1);
58554     } catch (std::out_of_range& e) {
58555       {
58556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58557       };
58558     } catch (std::exception& e) {
58559       {
58560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58561       };
58562     } catch (...) {
58563       {
58564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58565       };
58566     }
58567   }
58568   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58569   return jresult;
58570 }
58571
58572
58573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
58574   void * jresult ;
58575   Dali::Toolkit::TransitionData *arg1 = 0 ;
58576   Dali::Toolkit::TransitionData *result = 0 ;
58577
58578   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58579   if (!arg1) {
58580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58581     return 0;
58582   }
58583   {
58584     try {
58585       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
58586     } catch (std::out_of_range& e) {
58587       {
58588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58589       };
58590     } catch (std::exception& e) {
58591       {
58592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58593       };
58594     } catch (...) {
58595       {
58596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58597       };
58598     }
58599   }
58600   jresult = (void *)result;
58601   return jresult;
58602 }
58603
58604
58605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
58606   void * jresult ;
58607   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58608   Dali::Toolkit::TransitionData *arg2 = 0 ;
58609   Dali::Toolkit::TransitionData *result = 0 ;
58610
58611   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58612   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
58613   if (!arg2) {
58614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58615     return 0;
58616   }
58617   {
58618     try {
58619       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
58620     } catch (std::out_of_range& e) {
58621       {
58622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58623       };
58624     } catch (std::exception& e) {
58625       {
58626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58627       };
58628     } catch (...) {
58629       {
58630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58631       };
58632     }
58633   }
58634   jresult = (void *)result;
58635   return jresult;
58636 }
58637
58638
58639 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
58640   unsigned long jresult ;
58641   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58642   size_t result;
58643
58644   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58645   {
58646     try {
58647       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
58648     } catch (std::out_of_range& e) {
58649       {
58650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58651       };
58652     } catch (std::exception& e) {
58653       {
58654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58655       };
58656     } catch (...) {
58657       {
58658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58659       };
58660     }
58661   }
58662   jresult = (unsigned long)result;
58663   return jresult;
58664 }
58665
58666
58667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
58668   void * jresult ;
58669   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58670   size_t arg2 ;
58671   Dali::Property::Map result;
58672
58673   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58674   arg2 = (size_t)jarg2;
58675   {
58676     try {
58677       result = (arg1)->GetAnimatorAt(arg2);
58678     } catch (std::out_of_range& e) {
58679       {
58680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58681       };
58682     } catch (std::exception& e) {
58683       {
58684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58685       };
58686     } catch (...) {
58687       {
58688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58689       };
58690     }
58691   }
58692   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
58693   return jresult;
58694 }
58695
58696
58697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
58698   void * jresult ;
58699   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
58700   Dali::Toolkit::TransitionData *result = 0 ;
58701
58702   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
58703   {
58704     try {
58705       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
58706     } catch (std::out_of_range& e) {
58707       {
58708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58709       };
58710     } catch (std::exception& e) {
58711       {
58712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58713       };
58714     } catch (...) {
58715       {
58716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58717       };
58718     }
58719   }
58720   jresult = (void *)result;
58721   return jresult;
58722 }
58723
58724
58725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
58726   int jresult ;
58727   int result;
58728
58729   {
58730     try {
58731       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
58732     } catch (std::out_of_range& e) {
58733       {
58734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58735       };
58736     } catch (std::exception& e) {
58737       {
58738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58739       };
58740     } catch (...) {
58741       {
58742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58743       };
58744     }
58745   }
58746   jresult = (int)result;
58747   return jresult;
58748 }
58749
58750
58751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
58752   int jresult ;
58753   int result;
58754
58755   {
58756     try {
58757       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
58758     } catch (std::out_of_range& e) {
58759       {
58760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58761       };
58762     } catch (std::exception& e) {
58763       {
58764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58765       };
58766     } catch (...) {
58767       {
58768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58769       };
58770     }
58771   }
58772   jresult = (int)result;
58773   return jresult;
58774 }
58775
58776
58777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
58778   int jresult ;
58779   int result;
58780
58781   {
58782     try {
58783       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
58784     } catch (std::out_of_range& e) {
58785       {
58786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58787       };
58788     } catch (std::exception& e) {
58789       {
58790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58791       };
58792     } catch (...) {
58793       {
58794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58795       };
58796     }
58797   }
58798   jresult = (int)result;
58799   return jresult;
58800 }
58801
58802
58803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
58804   int jresult ;
58805   int result;
58806
58807   {
58808     try {
58809       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
58810     } catch (std::out_of_range& e) {
58811       {
58812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58813       };
58814     } catch (std::exception& e) {
58815       {
58816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58817       };
58818     } catch (...) {
58819       {
58820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58821       };
58822     }
58823   }
58824   jresult = (int)result;
58825   return jresult;
58826 }
58827
58828
58829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
58830   int jresult ;
58831   int result;
58832
58833   {
58834     try {
58835       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
58836     } catch (std::out_of_range& e) {
58837       {
58838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58839       };
58840     } catch (std::exception& e) {
58841       {
58842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58843       };
58844     } catch (...) {
58845       {
58846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58847       };
58848     }
58849   }
58850   jresult = (int)result;
58851   return jresult;
58852 }
58853
58854
58855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
58856   int jresult ;
58857   int result;
58858
58859   {
58860     try {
58861       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
58862     } catch (std::out_of_range& e) {
58863       {
58864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58865       };
58866     } catch (std::exception& e) {
58867       {
58868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58869       };
58870     } catch (...) {
58871       {
58872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58873       };
58874     }
58875   }
58876   jresult = (int)result;
58877   return jresult;
58878 }
58879
58880
58881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
58882   int jresult ;
58883   int result;
58884
58885   {
58886     try {
58887       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
58888     } catch (std::out_of_range& e) {
58889       {
58890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58891       };
58892     } catch (std::exception& e) {
58893       {
58894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58895       };
58896     } catch (...) {
58897       {
58898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58899       };
58900     }
58901   }
58902   jresult = (int)result;
58903   return jresult;
58904 }
58905
58906
58907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
58908   int jresult ;
58909   int result;
58910
58911   {
58912     try {
58913       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
58914     } catch (std::out_of_range& e) {
58915       {
58916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58917       };
58918     } catch (std::exception& e) {
58919       {
58920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58921       };
58922     } catch (...) {
58923       {
58924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58925       };
58926     }
58927   }
58928   jresult = (int)result;
58929   return jresult;
58930 }
58931
58932
58933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
58934   int jresult ;
58935   int result;
58936
58937   {
58938     try {
58939       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
58940     } catch (std::out_of_range& e) {
58941       {
58942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58943       };
58944     } catch (std::exception& e) {
58945       {
58946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58947       };
58948     } catch (...) {
58949       {
58950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58951       };
58952     }
58953   }
58954   jresult = (int)result;
58955   return jresult;
58956 }
58957
58958
58959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
58960   int jresult ;
58961   int result;
58962
58963   {
58964     try {
58965       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
58966     } catch (std::out_of_range& e) {
58967       {
58968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58969       };
58970     } catch (std::exception& e) {
58971       {
58972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58973       };
58974     } catch (...) {
58975       {
58976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58977       };
58978     }
58979   }
58980   jresult = (int)result;
58981   return jresult;
58982 }
58983
58984
58985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
58986   int jresult ;
58987   int result;
58988
58989   {
58990     try {
58991       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
58992     } catch (std::out_of_range& e) {
58993       {
58994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58995       };
58996     } catch (std::exception& e) {
58997       {
58998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58999       };
59000     } catch (...) {
59001       {
59002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59003       };
59004     }
59005   }
59006   jresult = (int)result;
59007   return jresult;
59008 }
59009
59010
59011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
59012   int jresult ;
59013   int result;
59014
59015   {
59016     try {
59017       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
59018     } catch (std::out_of_range& e) {
59019       {
59020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59021       };
59022     } catch (std::exception& e) {
59023       {
59024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59025       };
59026     } catch (...) {
59027       {
59028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59029       };
59030     }
59031   }
59032   jresult = (int)result;
59033   return jresult;
59034 }
59035
59036
59037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
59038   int jresult ;
59039   int result;
59040
59041   {
59042     try {
59043       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
59044     } catch (std::out_of_range& e) {
59045       {
59046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59047       };
59048     } catch (std::exception& e) {
59049       {
59050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59051       };
59052     } catch (...) {
59053       {
59054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59055       };
59056     }
59057   }
59058   jresult = (int)result;
59059   return jresult;
59060 }
59061
59062
59063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
59064   int jresult ;
59065   int result;
59066
59067   {
59068     try {
59069       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
59070     } catch (std::out_of_range& e) {
59071       {
59072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59073       };
59074     } catch (std::exception& e) {
59075       {
59076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59077       };
59078     } catch (...) {
59079       {
59080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59081       };
59082     }
59083   }
59084   jresult = (int)result;
59085   return jresult;
59086 }
59087
59088
59089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
59090   void * jresult ;
59091   Dali::Toolkit::Control result;
59092
59093   {
59094     try {
59095       result = Dali::Toolkit::Internal::Control::New();
59096     } catch (std::out_of_range& e) {
59097       {
59098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59099       };
59100     } catch (std::exception& e) {
59101       {
59102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59103       };
59104     } catch (...) {
59105       {
59106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59107       };
59108     }
59109   }
59110   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
59111   return jresult;
59112 }
59113
59114
59115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
59116   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59117   std::string *arg2 = 0 ;
59118
59119   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59120   if (!jarg2) {
59121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59122     return ;
59123   }
59124   std::string arg2_str(jarg2);
59125   arg2 = &arg2_str;
59126   {
59127     try {
59128       (arg1)->SetStyleName((std::string const &)*arg2);
59129     } catch (std::out_of_range& e) {
59130       {
59131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59132       };
59133     } catch (std::exception& e) {
59134       {
59135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59136       };
59137     } catch (...) {
59138       {
59139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59140       };
59141     }
59142   }
59143
59144   //argout typemap for const std::string&
59145
59146 }
59147
59148
59149 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
59150   char * jresult ;
59151   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59152   std::string *result = 0 ;
59153
59154   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59155   {
59156     try {
59157       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
59158     } catch (std::out_of_range& e) {
59159       {
59160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59161       };
59162     } catch (std::exception& e) {
59163       {
59164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59165       };
59166     } catch (...) {
59167       {
59168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59169       };
59170     }
59171   }
59172   jresult = SWIG_csharp_string_callback(result->c_str());
59173   return jresult;
59174 }
59175
59176
59177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
59178   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59179   Dali::Vector4 *arg2 = 0 ;
59180
59181   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59182   arg2 = (Dali::Vector4 *)jarg2;
59183   if (!arg2) {
59184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
59185     return ;
59186   }
59187   {
59188     try {
59189       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
59190     } catch (std::out_of_range& e) {
59191       {
59192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59193       };
59194     } catch (std::exception& e) {
59195       {
59196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59197       };
59198     } catch (...) {
59199       {
59200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59201       };
59202     }
59203   }
59204 }
59205
59206
59207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
59208   void * jresult ;
59209   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59210   Dali::Vector4 result;
59211
59212   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59213   {
59214     try {
59215       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
59216     } catch (std::out_of_range& e) {
59217       {
59218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59219       };
59220     } catch (std::exception& e) {
59221       {
59222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59223       };
59224     } catch (...) {
59225       {
59226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59227       };
59228     }
59229   }
59230   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
59231   return jresult;
59232 }
59233
59234
59235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
59236   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59237   Dali::Image arg2 ;
59238   Dali::Image *argp2 ;
59239
59240   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59241   argp2 = (Dali::Image *)jarg2;
59242   if (!argp2) {
59243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
59244     return ;
59245   }
59246   arg2 = *argp2;
59247   {
59248     try {
59249       (arg1)->SetBackgroundImage(arg2);
59250     } catch (std::out_of_range& e) {
59251       {
59252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59253       };
59254     } catch (std::exception& e) {
59255       {
59256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59257       };
59258     } catch (...) {
59259       {
59260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59261       };
59262     }
59263   }
59264 }
59265
59266
59267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
59268   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59269   Dali::Property::Map *arg2 = 0 ;
59270
59271   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59272   arg2 = (Dali::Property::Map *)jarg2;
59273   if (!arg2) {
59274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59275     return ;
59276   }
59277   {
59278     try {
59279       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
59280     } catch (std::out_of_range& e) {
59281       {
59282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59283       };
59284     } catch (std::exception& e) {
59285       {
59286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59287       };
59288     } catch (...) {
59289       {
59290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59291       };
59292     }
59293   }
59294 }
59295
59296
59297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
59298   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59299
59300   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59301   {
59302     try {
59303       (arg1)->ClearBackground();
59304     } catch (std::out_of_range& e) {
59305       {
59306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59307       };
59308     } catch (std::exception& e) {
59309       {
59310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59311       };
59312     } catch (...) {
59313       {
59314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59315       };
59316     }
59317   }
59318 }
59319
59320
59321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
59322   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59323   Dali::Gesture::Type arg2 ;
59324
59325   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59326   arg2 = (Dali::Gesture::Type)jarg2;
59327   {
59328     try {
59329       (arg1)->EnableGestureDetection(arg2);
59330     } catch (std::out_of_range& e) {
59331       {
59332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59333       };
59334     } catch (std::exception& e) {
59335       {
59336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59337       };
59338     } catch (...) {
59339       {
59340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59341       };
59342     }
59343   }
59344 }
59345
59346
59347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
59348   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59349   Dali::Gesture::Type arg2 ;
59350
59351   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59352   arg2 = (Dali::Gesture::Type)jarg2;
59353   {
59354     try {
59355       (arg1)->DisableGestureDetection(arg2);
59356     } catch (std::out_of_range& e) {
59357       {
59358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59359       };
59360     } catch (std::exception& e) {
59361       {
59362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59363       };
59364     } catch (...) {
59365       {
59366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59367       };
59368     }
59369   }
59370 }
59371
59372
59373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
59374   void * jresult ;
59375   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59376   Dali::PinchGestureDetector result;
59377
59378   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59379   {
59380     try {
59381       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
59382     } catch (std::out_of_range& e) {
59383       {
59384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59385       };
59386     } catch (std::exception& e) {
59387       {
59388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59389       };
59390     } catch (...) {
59391       {
59392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59393       };
59394     }
59395   }
59396   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
59397   return jresult;
59398 }
59399
59400
59401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
59402   void * jresult ;
59403   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59404   Dali::PanGestureDetector result;
59405
59406   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59407   {
59408     try {
59409       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
59410     } catch (std::out_of_range& e) {
59411       {
59412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59413       };
59414     } catch (std::exception& e) {
59415       {
59416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59417       };
59418     } catch (...) {
59419       {
59420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59421       };
59422     }
59423   }
59424   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
59425   return jresult;
59426 }
59427
59428
59429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
59430   void * jresult ;
59431   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59432   Dali::TapGestureDetector result;
59433
59434   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59435   {
59436     try {
59437       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
59438     } catch (std::out_of_range& e) {
59439       {
59440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59441       };
59442     } catch (std::exception& e) {
59443       {
59444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59445       };
59446     } catch (...) {
59447       {
59448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59449       };
59450     }
59451   }
59452   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
59453   return jresult;
59454 }
59455
59456
59457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
59458   void * jresult ;
59459   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59460   Dali::LongPressGestureDetector result;
59461
59462   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59463   {
59464     try {
59465       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
59466     } catch (std::out_of_range& e) {
59467       {
59468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59469       };
59470     } catch (std::exception& e) {
59471       {
59472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59473       };
59474     } catch (...) {
59475       {
59476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59477       };
59478     }
59479   }
59480   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
59481   return jresult;
59482 }
59483
59484
59485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
59486   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59487   bool arg2 ;
59488
59489   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59490   arg2 = jarg2 ? true : false;
59491   {
59492     try {
59493       (arg1)->SetKeyboardNavigationSupport(arg2);
59494     } catch (std::out_of_range& e) {
59495       {
59496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59497       };
59498     } catch (std::exception& e) {
59499       {
59500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59501       };
59502     } catch (...) {
59503       {
59504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59505       };
59506     }
59507   }
59508 }
59509
59510
59511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
59512   unsigned int jresult ;
59513   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59514   bool result;
59515
59516   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59517   {
59518     try {
59519       result = (bool)(arg1)->IsKeyboardNavigationSupported();
59520     } catch (std::out_of_range& e) {
59521       {
59522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59523       };
59524     } catch (std::exception& e) {
59525       {
59526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59527       };
59528     } catch (...) {
59529       {
59530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59531       };
59532     }
59533   }
59534   jresult = result;
59535   return jresult;
59536 }
59537
59538
59539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
59540   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59541
59542   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59543   {
59544     try {
59545       (arg1)->SetKeyInputFocus();
59546     } catch (std::out_of_range& e) {
59547       {
59548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59549       };
59550     } catch (std::exception& e) {
59551       {
59552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59553       };
59554     } catch (...) {
59555       {
59556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59557       };
59558     }
59559   }
59560 }
59561
59562
59563 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
59564   unsigned int jresult ;
59565   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59566   bool result;
59567
59568   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59569   {
59570     try {
59571       result = (bool)(arg1)->HasKeyInputFocus();
59572     } catch (std::out_of_range& e) {
59573       {
59574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59575       };
59576     } catch (std::exception& e) {
59577       {
59578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59579       };
59580     } catch (...) {
59581       {
59582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59583       };
59584     }
59585   }
59586   jresult = result;
59587   return jresult;
59588 }
59589
59590
59591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
59592   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59593
59594   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59595   {
59596     try {
59597       (arg1)->ClearKeyInputFocus();
59598     } catch (std::out_of_range& e) {
59599       {
59600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59601       };
59602     } catch (std::exception& e) {
59603       {
59604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59605       };
59606     } catch (...) {
59607       {
59608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59609       };
59610     }
59611   }
59612 }
59613
59614
59615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
59616   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59617   bool arg2 ;
59618
59619   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59620   arg2 = jarg2 ? true : false;
59621   {
59622     try {
59623       (arg1)->SetAsKeyboardFocusGroup(arg2);
59624     } catch (std::out_of_range& e) {
59625       {
59626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59627       };
59628     } catch (std::exception& e) {
59629       {
59630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59631       };
59632     } catch (...) {
59633       {
59634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59635       };
59636     }
59637   }
59638 }
59639
59640
59641 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
59642   unsigned int jresult ;
59643   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59644   bool result;
59645
59646   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59647   {
59648     try {
59649       result = (bool)(arg1)->IsKeyboardFocusGroup();
59650     } catch (std::out_of_range& e) {
59651       {
59652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59653       };
59654     } catch (std::exception& e) {
59655       {
59656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59657       };
59658     } catch (...) {
59659       {
59660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59661       };
59662     }
59663   }
59664   jresult = result;
59665   return jresult;
59666 }
59667
59668
59669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(void * jarg1) {
59670   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59671
59672   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59673   {
59674     try {
59675       (arg1)->AccessibilityActivate();
59676     } catch (std::out_of_range& e) {
59677       {
59678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59679       };
59680     } catch (std::exception& e) {
59681       {
59682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59683       };
59684     } catch (...) {
59685       {
59686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59687       };
59688     }
59689   }
59690 }
59691
59692
59693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
59694   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59695
59696   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59697   {
59698     try {
59699       (arg1)->KeyboardEnter();
59700     } catch (std::out_of_range& e) {
59701       {
59702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59703       };
59704     } catch (std::exception& e) {
59705       {
59706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59707       };
59708     } catch (...) {
59709       {
59710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59711       };
59712     }
59713   }
59714 }
59715
59716
59717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
59718   void * jresult ;
59719   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59720   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
59721
59722   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59723   {
59724     try {
59725       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
59726     } catch (std::out_of_range& e) {
59727       {
59728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59729       };
59730     } catch (std::exception& e) {
59731       {
59732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59733       };
59734     } catch (...) {
59735       {
59736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59737       };
59738     }
59739   }
59740   jresult = (void *)result;
59741   return jresult;
59742 }
59743
59744
59745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
59746   void * jresult ;
59747   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59748   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59749
59750   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59751   {
59752     try {
59753       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
59754     } catch (std::out_of_range& e) {
59755       {
59756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59757       };
59758     } catch (std::exception& e) {
59759       {
59760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59761       };
59762     } catch (...) {
59763       {
59764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59765       };
59766     }
59767   }
59768   jresult = (void *)result;
59769   return jresult;
59770 }
59771
59772
59773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
59774   void * jresult ;
59775   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59776   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59777
59778   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59779   {
59780     try {
59781       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
59782     } catch (std::out_of_range& e) {
59783       {
59784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59785       };
59786     } catch (std::exception& e) {
59787       {
59788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59789       };
59790     } catch (...) {
59791       {
59792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59793       };
59794     }
59795   }
59796   jresult = (void *)result;
59797   return jresult;
59798 }
59799
59800
59801 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
59802   unsigned int jresult ;
59803   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59804   Dali::KeyEvent *arg2 = 0 ;
59805   bool result;
59806
59807   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59808   arg2 = (Dali::KeyEvent *)jarg2;
59809   if (!arg2) {
59810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
59811     return 0;
59812   }
59813   {
59814     try {
59815       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
59816     } catch (std::out_of_range& e) {
59817       {
59818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59819       };
59820     } catch (std::exception& e) {
59821       {
59822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59823       };
59824     } catch (...) {
59825       {
59826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59827       };
59828     }
59829   }
59830   jresult = result;
59831   return jresult;
59832 }
59833
59834
59835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
59836   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59837   int arg2 ;
59838   SwigDirector_ViewImpl *darg = 0;
59839
59840   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59841   arg2 = (int)jarg2;
59842   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59843   {
59844     try {
59845       (darg)->OnStageConnection(arg2);
59846     } catch (std::out_of_range& e) {
59847       {
59848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59849       };
59850     } catch (std::exception& e) {
59851       {
59852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59853       };
59854     } catch (...) {
59855       {
59856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59857       };
59858     }
59859   }
59860 }
59861
59862
59863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
59864   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59865   int arg2 ;
59866   SwigDirector_ViewImpl *darg = 0;
59867
59868   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59869   arg2 = (int)jarg2;
59870   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59871   {
59872     try {
59873       (darg)->OnStageConnectionSwigPublic(arg2);
59874     } catch (std::out_of_range& e) {
59875       {
59876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59877       };
59878     } catch (std::exception& e) {
59879       {
59880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59881       };
59882     } catch (...) {
59883       {
59884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59885       };
59886     }
59887   }
59888 }
59889
59890
59891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
59892   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59893   SwigDirector_ViewImpl *darg = 0;
59894
59895   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59896   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59897   {
59898     try {
59899       (darg)->OnStageDisconnection();
59900     } catch (std::out_of_range& e) {
59901       {
59902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59903       };
59904     } catch (std::exception& e) {
59905       {
59906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59907       };
59908     } catch (...) {
59909       {
59910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59911       };
59912     }
59913   }
59914 }
59915
59916
59917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
59918   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59919   SwigDirector_ViewImpl *darg = 0;
59920
59921   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59922   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59923   {
59924     try {
59925       (darg)->OnStageDisconnectionSwigPublic();
59926     } catch (std::out_of_range& e) {
59927       {
59928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59929       };
59930     } catch (std::exception& e) {
59931       {
59932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59933       };
59934     } catch (...) {
59935       {
59936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59937       };
59938     }
59939   }
59940 }
59941
59942
59943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
59944   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59945   Dali::Actor *arg2 = 0 ;
59946   SwigDirector_ViewImpl *darg = 0;
59947
59948   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59949   arg2 = (Dali::Actor *)jarg2;
59950   if (!arg2) {
59951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59952     return ;
59953   }
59954   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59955   {
59956     try {
59957       (darg)->OnChildAdd(*arg2);
59958     } catch (std::out_of_range& e) {
59959       {
59960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59961       };
59962     } catch (std::exception& e) {
59963       {
59964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59965       };
59966     } catch (...) {
59967       {
59968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59969       };
59970     }
59971   }
59972 }
59973
59974
59975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59976   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59977   Dali::Actor *arg2 = 0 ;
59978   SwigDirector_ViewImpl *darg = 0;
59979
59980   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59981   arg2 = (Dali::Actor *)jarg2;
59982   if (!arg2) {
59983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59984     return ;
59985   }
59986   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59987   {
59988     try {
59989       (darg)->OnChildAddSwigPublic(*arg2);
59990     } catch (std::out_of_range& e) {
59991       {
59992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59993       };
59994     } catch (std::exception& e) {
59995       {
59996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59997       };
59998     } catch (...) {
59999       {
60000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60001       };
60002     }
60003   }
60004 }
60005
60006
60007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
60008   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60009   Dali::Actor *arg2 = 0 ;
60010   SwigDirector_ViewImpl *darg = 0;
60011
60012   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60013   arg2 = (Dali::Actor *)jarg2;
60014   if (!arg2) {
60015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60016     return ;
60017   }
60018   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60019   {
60020     try {
60021       (darg)->OnChildRemove(*arg2);
60022     } catch (std::out_of_range& e) {
60023       {
60024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60025       };
60026     } catch (std::exception& e) {
60027       {
60028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60029       };
60030     } catch (...) {
60031       {
60032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60033       };
60034     }
60035   }
60036 }
60037
60038
60039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60040   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60041   Dali::Actor *arg2 = 0 ;
60042   SwigDirector_ViewImpl *darg = 0;
60043
60044   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60045   arg2 = (Dali::Actor *)jarg2;
60046   if (!arg2) {
60047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60048     return ;
60049   }
60050   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60051   {
60052     try {
60053       (darg)->OnChildRemoveSwigPublic(*arg2);
60054     } catch (std::out_of_range& e) {
60055       {
60056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60057       };
60058     } catch (std::exception& e) {
60059       {
60060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60061       };
60062     } catch (...) {
60063       {
60064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60065       };
60066     }
60067   }
60068 }
60069
60070
60071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
60072   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60073   Dali::Property::Index arg2 ;
60074   Dali::Property::Value arg3 ;
60075   Dali::Property::Value *argp3 ;
60076   SwigDirector_ViewImpl *darg = 0;
60077
60078   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60079   arg2 = (Dali::Property::Index)jarg2;
60080   argp3 = (Dali::Property::Value *)jarg3;
60081   if (!argp3) {
60082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60083     return ;
60084   }
60085   arg3 = *argp3;
60086   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60087   {
60088     try {
60089       (darg)->OnPropertySet(arg2,arg3);
60090     } catch (std::out_of_range& e) {
60091       {
60092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60093       };
60094     } catch (std::exception& e) {
60095       {
60096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60097       };
60098     } catch (...) {
60099       {
60100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60101       };
60102     }
60103   }
60104 }
60105
60106
60107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
60108   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60109   Dali::Property::Index arg2 ;
60110   Dali::Property::Value arg3 ;
60111   Dali::Property::Value *argp3 ;
60112   SwigDirector_ViewImpl *darg = 0;
60113
60114   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60115   arg2 = (Dali::Property::Index)jarg2;
60116   argp3 = (Dali::Property::Value *)jarg3;
60117   if (!argp3) {
60118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60119     return ;
60120   }
60121   arg3 = *argp3;
60122   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60123   {
60124     try {
60125       (darg)->OnPropertySetSwigPublic(arg2,arg3);
60126     } catch (std::out_of_range& e) {
60127       {
60128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60129       };
60130     } catch (std::exception& e) {
60131       {
60132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60133       };
60134     } catch (...) {
60135       {
60136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60137       };
60138     }
60139   }
60140 }
60141
60142
60143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
60144   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60145   Dali::Vector3 *arg2 = 0 ;
60146   SwigDirector_ViewImpl *darg = 0;
60147
60148   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60149   arg2 = (Dali::Vector3 *)jarg2;
60150   if (!arg2) {
60151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60152     return ;
60153   }
60154   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60155   {
60156     try {
60157       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
60158     } catch (std::out_of_range& e) {
60159       {
60160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60161       };
60162     } catch (std::exception& e) {
60163       {
60164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60165       };
60166     } catch (...) {
60167       {
60168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60169       };
60170     }
60171   }
60172 }
60173
60174
60175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60176   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60177   Dali::Vector3 *arg2 = 0 ;
60178   SwigDirector_ViewImpl *darg = 0;
60179
60180   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60181   arg2 = (Dali::Vector3 *)jarg2;
60182   if (!arg2) {
60183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60184     return ;
60185   }
60186   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60187   {
60188     try {
60189       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
60190     } catch (std::out_of_range& e) {
60191       {
60192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60193       };
60194     } catch (std::exception& e) {
60195       {
60196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60197       };
60198     } catch (...) {
60199       {
60200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60201       };
60202     }
60203   }
60204 }
60205
60206
60207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
60208   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60209   Dali::Animation *arg2 = 0 ;
60210   Dali::Vector3 *arg3 = 0 ;
60211   SwigDirector_ViewImpl *darg = 0;
60212
60213   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60214   arg2 = (Dali::Animation *)jarg2;
60215   if (!arg2) {
60216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60217     return ;
60218   }
60219   arg3 = (Dali::Vector3 *)jarg3;
60220   if (!arg3) {
60221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60222     return ;
60223   }
60224   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60225   {
60226     try {
60227       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
60228     } catch (std::out_of_range& e) {
60229       {
60230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60231       };
60232     } catch (std::exception& e) {
60233       {
60234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60235       };
60236     } catch (...) {
60237       {
60238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60239       };
60240     }
60241   }
60242 }
60243
60244
60245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60246   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60247   Dali::Animation *arg2 = 0 ;
60248   Dali::Vector3 *arg3 = 0 ;
60249   SwigDirector_ViewImpl *darg = 0;
60250
60251   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60252   arg2 = (Dali::Animation *)jarg2;
60253   if (!arg2) {
60254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60255     return ;
60256   }
60257   arg3 = (Dali::Vector3 *)jarg3;
60258   if (!arg3) {
60259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60260     return ;
60261   }
60262   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60263   {
60264     try {
60265       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
60266     } catch (std::out_of_range& e) {
60267       {
60268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60269       };
60270     } catch (std::exception& e) {
60271       {
60272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60273       };
60274     } catch (...) {
60275       {
60276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60277       };
60278     }
60279   }
60280 }
60281
60282
60283 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
60284   unsigned int jresult ;
60285   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60286   Dali::TouchEvent *arg2 = 0 ;
60287   SwigDirector_ViewImpl *darg = 0;
60288   bool result;
60289
60290   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60291   arg2 = (Dali::TouchEvent *)jarg2;
60292   if (!arg2) {
60293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
60294     return 0;
60295   }
60296   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60297   {
60298     try {
60299       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
60300     } catch (std::out_of_range& e) {
60301       {
60302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60303       };
60304     } catch (std::exception& e) {
60305       {
60306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60307       };
60308     } catch (...) {
60309       {
60310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60311       };
60312     }
60313   }
60314   jresult = result;
60315   return jresult;
60316 }
60317
60318
60319 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60320   unsigned int jresult ;
60321   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60322   Dali::TouchEvent *arg2 = 0 ;
60323   SwigDirector_ViewImpl *darg = 0;
60324   bool result;
60325
60326   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60327   arg2 = (Dali::TouchEvent *)jarg2;
60328   if (!arg2) {
60329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
60330     return 0;
60331   }
60332   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60333   {
60334     try {
60335       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
60336     } catch (std::out_of_range& e) {
60337       {
60338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60339       };
60340     } catch (std::exception& e) {
60341       {
60342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60343       };
60344     } catch (...) {
60345       {
60346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60347       };
60348     }
60349   }
60350   jresult = result;
60351   return jresult;
60352 }
60353
60354
60355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
60356   unsigned int jresult ;
60357   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60358   Dali::HoverEvent *arg2 = 0 ;
60359   SwigDirector_ViewImpl *darg = 0;
60360   bool result;
60361
60362   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60363   arg2 = (Dali::HoverEvent *)jarg2;
60364   if (!arg2) {
60365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60366     return 0;
60367   }
60368   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60369   {
60370     try {
60371       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
60372     } catch (std::out_of_range& e) {
60373       {
60374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60375       };
60376     } catch (std::exception& e) {
60377       {
60378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60379       };
60380     } catch (...) {
60381       {
60382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60383       };
60384     }
60385   }
60386   jresult = result;
60387   return jresult;
60388 }
60389
60390
60391 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60392   unsigned int jresult ;
60393   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60394   Dali::HoverEvent *arg2 = 0 ;
60395   SwigDirector_ViewImpl *darg = 0;
60396   bool result;
60397
60398   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60399   arg2 = (Dali::HoverEvent *)jarg2;
60400   if (!arg2) {
60401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60402     return 0;
60403   }
60404   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60405   {
60406     try {
60407       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
60408     } catch (std::out_of_range& e) {
60409       {
60410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60411       };
60412     } catch (std::exception& e) {
60413       {
60414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60415       };
60416     } catch (...) {
60417       {
60418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60419       };
60420     }
60421   }
60422   jresult = result;
60423   return jresult;
60424 }
60425
60426
60427 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
60428   unsigned int jresult ;
60429   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60430   Dali::KeyEvent *arg2 = 0 ;
60431   SwigDirector_ViewImpl *darg = 0;
60432   bool result;
60433
60434   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60435   arg2 = (Dali::KeyEvent *)jarg2;
60436   if (!arg2) {
60437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60438     return 0;
60439   }
60440   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60441   {
60442     try {
60443       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
60444     } catch (std::out_of_range& e) {
60445       {
60446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60447       };
60448     } catch (std::exception& e) {
60449       {
60450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60451       };
60452     } catch (...) {
60453       {
60454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60455       };
60456     }
60457   }
60458   jresult = result;
60459   return jresult;
60460 }
60461
60462
60463 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60464   unsigned int jresult ;
60465   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60466   Dali::KeyEvent *arg2 = 0 ;
60467   SwigDirector_ViewImpl *darg = 0;
60468   bool result;
60469
60470   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60471   arg2 = (Dali::KeyEvent *)jarg2;
60472   if (!arg2) {
60473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60474     return 0;
60475   }
60476   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60477   {
60478     try {
60479       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
60480     } catch (std::out_of_range& e) {
60481       {
60482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60483       };
60484     } catch (std::exception& e) {
60485       {
60486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60487       };
60488     } catch (...) {
60489       {
60490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60491       };
60492     }
60493   }
60494   jresult = result;
60495   return jresult;
60496 }
60497
60498
60499 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
60500   unsigned int jresult ;
60501   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60502   Dali::WheelEvent *arg2 = 0 ;
60503   SwigDirector_ViewImpl *darg = 0;
60504   bool result;
60505
60506   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60507   arg2 = (Dali::WheelEvent *)jarg2;
60508   if (!arg2) {
60509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60510     return 0;
60511   }
60512   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60513   {
60514     try {
60515       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
60516     } catch (std::out_of_range& e) {
60517       {
60518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60519       };
60520     } catch (std::exception& e) {
60521       {
60522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60523       };
60524     } catch (...) {
60525       {
60526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60527       };
60528     }
60529   }
60530   jresult = result;
60531   return jresult;
60532 }
60533
60534
60535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60536   unsigned int jresult ;
60537   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60538   Dali::WheelEvent *arg2 = 0 ;
60539   SwigDirector_ViewImpl *darg = 0;
60540   bool result;
60541
60542   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60543   arg2 = (Dali::WheelEvent *)jarg2;
60544   if (!arg2) {
60545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60546     return 0;
60547   }
60548   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60549   {
60550     try {
60551       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
60552     } catch (std::out_of_range& e) {
60553       {
60554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60555       };
60556     } catch (std::exception& e) {
60557       {
60558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60559       };
60560     } catch (...) {
60561       {
60562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60563       };
60564     }
60565   }
60566   jresult = result;
60567   return jresult;
60568 }
60569
60570
60571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
60572   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60573   Dali::Vector2 *arg2 = 0 ;
60574   Dali::RelayoutContainer *arg3 = 0 ;
60575   SwigDirector_ViewImpl *darg = 0;
60576
60577   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60578   arg2 = (Dali::Vector2 *)jarg2;
60579   if (!arg2) {
60580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60581     return ;
60582   }
60583   arg3 = (Dali::RelayoutContainer *)jarg3;
60584   if (!arg3) {
60585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60586     return ;
60587   }
60588   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60589   {
60590     try {
60591       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
60592     } catch (std::out_of_range& e) {
60593       {
60594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60595       };
60596     } catch (std::exception& e) {
60597       {
60598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60599       };
60600     } catch (...) {
60601       {
60602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60603       };
60604     }
60605   }
60606 }
60607
60608
60609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60610   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60611   Dali::Vector2 *arg2 = 0 ;
60612   Dali::RelayoutContainer *arg3 = 0 ;
60613   SwigDirector_ViewImpl *darg = 0;
60614
60615   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60616   arg2 = (Dali::Vector2 *)jarg2;
60617   if (!arg2) {
60618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60619     return ;
60620   }
60621   arg3 = (Dali::RelayoutContainer *)jarg3;
60622   if (!arg3) {
60623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60624     return ;
60625   }
60626   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60627   {
60628     try {
60629       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
60630     } catch (std::out_of_range& e) {
60631       {
60632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60633       };
60634     } catch (std::exception& e) {
60635       {
60636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60637       };
60638     } catch (...) {
60639       {
60640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60641       };
60642     }
60643   }
60644 }
60645
60646
60647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
60648   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60649   Dali::ResizePolicy::Type arg2 ;
60650   Dali::Dimension::Type arg3 ;
60651   SwigDirector_ViewImpl *darg = 0;
60652
60653   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60654   arg2 = (Dali::ResizePolicy::Type)jarg2;
60655   arg3 = (Dali::Dimension::Type)jarg3;
60656   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60657   {
60658     try {
60659       (darg)->OnSetResizePolicy(arg2,arg3);
60660     } catch (std::out_of_range& e) {
60661       {
60662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60663       };
60664     } catch (std::exception& e) {
60665       {
60666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60667       };
60668     } catch (...) {
60669       {
60670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60671       };
60672     }
60673   }
60674 }
60675
60676
60677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
60678   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60679   Dali::ResizePolicy::Type arg2 ;
60680   Dali::Dimension::Type arg3 ;
60681   SwigDirector_ViewImpl *darg = 0;
60682
60683   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60684   arg2 = (Dali::ResizePolicy::Type)jarg2;
60685   arg3 = (Dali::Dimension::Type)jarg3;
60686   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60687   {
60688     try {
60689       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
60690     } catch (std::out_of_range& e) {
60691       {
60692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60693       };
60694     } catch (std::exception& e) {
60695       {
60696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60697       };
60698     } catch (...) {
60699       {
60700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60701       };
60702     }
60703   }
60704 }
60705
60706
60707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
60708   void * jresult ;
60709   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60710   SwigDirector_ViewImpl *darg = 0;
60711   Dali::Vector3 result;
60712
60713   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60714   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60715   {
60716     try {
60717       result = (darg)->GetNaturalSize();
60718     } catch (std::out_of_range& e) {
60719       {
60720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60721       };
60722     } catch (std::exception& e) {
60723       {
60724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60725       };
60726     } catch (...) {
60727       {
60728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60729       };
60730     }
60731   }
60732   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
60733   return jresult;
60734 }
60735
60736
60737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
60738   void * jresult ;
60739   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60740   SwigDirector_ViewImpl *darg = 0;
60741   Dali::Vector3 result;
60742
60743   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60744   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60745   {
60746     try {
60747       result = (darg)->GetNaturalSizeSwigPublic();
60748     } catch (std::out_of_range& e) {
60749       {
60750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60751       };
60752     } catch (std::exception& e) {
60753       {
60754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60755       };
60756     } catch (...) {
60757       {
60758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60759       };
60760     }
60761   }
60762   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
60763   return jresult;
60764 }
60765
60766
60767 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
60768   float jresult ;
60769   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60770   Dali::Actor *arg2 = 0 ;
60771   Dali::Dimension::Type arg3 ;
60772   SwigDirector_ViewImpl *darg = 0;
60773   float result;
60774
60775   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60776   arg2 = (Dali::Actor *)jarg2;
60777   if (!arg2) {
60778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
60779     return 0;
60780   }
60781   arg3 = (Dali::Dimension::Type)jarg3;
60782   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60783   {
60784     try {
60785       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
60786     } catch (std::out_of_range& e) {
60787       {
60788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60789       };
60790     } catch (std::exception& e) {
60791       {
60792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60793       };
60794     } catch (...) {
60795       {
60796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60797       };
60798     }
60799   }
60800   jresult = result;
60801   return jresult;
60802 }
60803
60804
60805 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
60806   float jresult ;
60807   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60808   Dali::Actor *arg2 = 0 ;
60809   Dali::Dimension::Type arg3 ;
60810   SwigDirector_ViewImpl *darg = 0;
60811   float result;
60812
60813   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60814   arg2 = (Dali::Actor *)jarg2;
60815   if (!arg2) {
60816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
60817     return 0;
60818   }
60819   arg3 = (Dali::Dimension::Type)jarg3;
60820   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60821   {
60822     try {
60823       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
60824     } catch (std::out_of_range& e) {
60825       {
60826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60827       };
60828     } catch (std::exception& e) {
60829       {
60830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60831       };
60832     } catch (...) {
60833       {
60834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60835       };
60836     }
60837   }
60838   jresult = result;
60839   return jresult;
60840 }
60841
60842
60843 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
60844   float jresult ;
60845   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60846   float arg2 ;
60847   SwigDirector_ViewImpl *darg = 0;
60848   float result;
60849
60850   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60851   arg2 = (float)jarg2;
60852   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60853   {
60854     try {
60855       result = (float)(darg)->GetHeightForWidth(arg2);
60856     } catch (std::out_of_range& e) {
60857       {
60858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60859       };
60860     } catch (std::exception& e) {
60861       {
60862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60863       };
60864     } catch (...) {
60865       {
60866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60867       };
60868     }
60869   }
60870   jresult = result;
60871   return jresult;
60872 }
60873
60874
60875 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
60876   float jresult ;
60877   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60878   float arg2 ;
60879   SwigDirector_ViewImpl *darg = 0;
60880   float result;
60881
60882   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60883   arg2 = (float)jarg2;
60884   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60885   {
60886     try {
60887       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
60888     } catch (std::out_of_range& e) {
60889       {
60890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60891       };
60892     } catch (std::exception& e) {
60893       {
60894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60895       };
60896     } catch (...) {
60897       {
60898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60899       };
60900     }
60901   }
60902   jresult = result;
60903   return jresult;
60904 }
60905
60906
60907 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
60908   float jresult ;
60909   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60910   float arg2 ;
60911   SwigDirector_ViewImpl *darg = 0;
60912   float result;
60913
60914   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60915   arg2 = (float)jarg2;
60916   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60917   {
60918     try {
60919       result = (float)(darg)->GetWidthForHeight(arg2);
60920     } catch (std::out_of_range& e) {
60921       {
60922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60923       };
60924     } catch (std::exception& e) {
60925       {
60926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60927       };
60928     } catch (...) {
60929       {
60930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60931       };
60932     }
60933   }
60934   jresult = result;
60935   return jresult;
60936 }
60937
60938
60939 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
60940   float jresult ;
60941   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60942   float arg2 ;
60943   SwigDirector_ViewImpl *darg = 0;
60944   float result;
60945
60946   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60947   arg2 = (float)jarg2;
60948   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60949   {
60950     try {
60951       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
60952     } catch (std::out_of_range& e) {
60953       {
60954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60955       };
60956     } catch (std::exception& e) {
60957       {
60958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60959       };
60960     } catch (...) {
60961       {
60962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60963       };
60964     }
60965   }
60966   jresult = result;
60967   return jresult;
60968 }
60969
60970
60971 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
60972   unsigned int jresult ;
60973   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60974   Dali::Dimension::Type arg2 ;
60975   SwigDirector_ViewImpl *darg = 0;
60976   bool result;
60977
60978   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60979   arg2 = (Dali::Dimension::Type)jarg2;
60980   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60981   {
60982     try {
60983       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
60984     } catch (std::out_of_range& e) {
60985       {
60986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60987       };
60988     } catch (std::exception& e) {
60989       {
60990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60991       };
60992     } catch (...) {
60993       {
60994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60995       };
60996     }
60997   }
60998   jresult = result;
60999   return jresult;
61000 }
61001
61002
61003 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
61004   unsigned int jresult ;
61005   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61006   Dali::Dimension::Type arg2 ;
61007   SwigDirector_ViewImpl *darg = 0;
61008   bool result;
61009
61010   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61011   arg2 = (Dali::Dimension::Type)jarg2;
61012   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61013   {
61014     try {
61015       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
61016     } catch (std::out_of_range& e) {
61017       {
61018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61019       };
61020     } catch (std::exception& e) {
61021       {
61022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61023       };
61024     } catch (...) {
61025       {
61026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61027       };
61028     }
61029   }
61030   jresult = result;
61031   return jresult;
61032 }
61033
61034
61035 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
61036   unsigned int jresult ;
61037   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61038   SwigDirector_ViewImpl *darg = 0;
61039   bool result;
61040
61041   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61042   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61043   {
61044     try {
61045       result = (bool)(darg)->RelayoutDependentOnChildren();
61046     } catch (std::out_of_range& e) {
61047       {
61048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61049       };
61050     } catch (std::exception& e) {
61051       {
61052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61053       };
61054     } catch (...) {
61055       {
61056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61057       };
61058     }
61059   }
61060   jresult = result;
61061   return jresult;
61062 }
61063
61064
61065 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
61066   unsigned int jresult ;
61067   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61068   SwigDirector_ViewImpl *darg = 0;
61069   bool result;
61070
61071   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61072   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61073   {
61074     try {
61075       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
61076     } catch (std::out_of_range& e) {
61077       {
61078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61079       };
61080     } catch (std::exception& e) {
61081       {
61082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61083       };
61084     } catch (...) {
61085       {
61086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61087       };
61088     }
61089   }
61090   jresult = result;
61091   return jresult;
61092 }
61093
61094
61095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
61096   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61097   Dali::Dimension::Type arg2 ;
61098   SwigDirector_ViewImpl *darg = 0;
61099
61100   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61101   arg2 = (Dali::Dimension::Type)jarg2;
61102   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61103   {
61104     try {
61105       (darg)->OnCalculateRelayoutSize(arg2);
61106     } catch (std::out_of_range& e) {
61107       {
61108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61109       };
61110     } catch (std::exception& e) {
61111       {
61112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61113       };
61114     } catch (...) {
61115       {
61116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61117       };
61118     }
61119   }
61120 }
61121
61122
61123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
61124   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61125   Dali::Dimension::Type arg2 ;
61126   SwigDirector_ViewImpl *darg = 0;
61127
61128   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61129   arg2 = (Dali::Dimension::Type)jarg2;
61130   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61131   {
61132     try {
61133       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
61134     } catch (std::out_of_range& e) {
61135       {
61136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61137       };
61138     } catch (std::exception& e) {
61139       {
61140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61141       };
61142     } catch (...) {
61143       {
61144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61145       };
61146     }
61147   }
61148 }
61149
61150
61151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
61152   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61153   float arg2 ;
61154   Dali::Dimension::Type arg3 ;
61155   SwigDirector_ViewImpl *darg = 0;
61156
61157   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61158   arg2 = (float)jarg2;
61159   arg3 = (Dali::Dimension::Type)jarg3;
61160   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61161   {
61162     try {
61163       (darg)->OnLayoutNegotiated(arg2,arg3);
61164     } catch (std::out_of_range& e) {
61165       {
61166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61167       };
61168     } catch (std::exception& e) {
61169       {
61170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61171       };
61172     } catch (...) {
61173       {
61174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61175       };
61176     }
61177   }
61178 }
61179
61180
61181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
61182   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61183   float arg2 ;
61184   Dali::Dimension::Type arg3 ;
61185   SwigDirector_ViewImpl *darg = 0;
61186
61187   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61188   arg2 = (float)jarg2;
61189   arg3 = (Dali::Dimension::Type)jarg3;
61190   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61191   {
61192     try {
61193       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
61194     } catch (std::out_of_range& e) {
61195       {
61196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61197       };
61198     } catch (std::exception& e) {
61199       {
61200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61201       };
61202     } catch (...) {
61203       {
61204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61205       };
61206     }
61207   }
61208 }
61209
61210
61211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
61212   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61213
61214   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61215   {
61216     try {
61217       (arg1)->OnInitialize();
61218     } catch (std::out_of_range& e) {
61219       {
61220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61221       };
61222     } catch (std::exception& e) {
61223       {
61224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61225       };
61226     } catch (...) {
61227       {
61228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61229       };
61230     }
61231   }
61232 }
61233
61234
61235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
61236   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61237
61238   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61239   {
61240     try {
61241       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
61242     } catch (std::out_of_range& e) {
61243       {
61244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61245       };
61246     } catch (std::exception& e) {
61247       {
61248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61249       };
61250     } catch (...) {
61251       {
61252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61253       };
61254     }
61255   }
61256 }
61257
61258
61259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
61260   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61261   Dali::Actor *arg2 = 0 ;
61262
61263   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61264   arg2 = (Dali::Actor *)jarg2;
61265   if (!arg2) {
61266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61267     return ;
61268   }
61269   {
61270     try {
61271       (arg1)->OnControlChildAdd(*arg2);
61272     } catch (std::out_of_range& e) {
61273       {
61274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61275       };
61276     } catch (std::exception& e) {
61277       {
61278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61279       };
61280     } catch (...) {
61281       {
61282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61283       };
61284     }
61285   }
61286 }
61287
61288
61289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61290   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61291   Dali::Actor *arg2 = 0 ;
61292
61293   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61294   arg2 = (Dali::Actor *)jarg2;
61295   if (!arg2) {
61296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61297     return ;
61298   }
61299   {
61300     try {
61301       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
61302     } catch (std::out_of_range& e) {
61303       {
61304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61305       };
61306     } catch (std::exception& e) {
61307       {
61308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61309       };
61310     } catch (...) {
61311       {
61312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61313       };
61314     }
61315   }
61316 }
61317
61318
61319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
61320   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61321   Dali::Actor *arg2 = 0 ;
61322
61323   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61324   arg2 = (Dali::Actor *)jarg2;
61325   if (!arg2) {
61326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61327     return ;
61328   }
61329   {
61330     try {
61331       (arg1)->OnControlChildRemove(*arg2);
61332     } catch (std::out_of_range& e) {
61333       {
61334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61335       };
61336     } catch (std::exception& e) {
61337       {
61338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61339       };
61340     } catch (...) {
61341       {
61342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61343       };
61344     }
61345   }
61346 }
61347
61348
61349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61350   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61351   Dali::Actor *arg2 = 0 ;
61352
61353   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61354   arg2 = (Dali::Actor *)jarg2;
61355   if (!arg2) {
61356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61357     return ;
61358   }
61359   {
61360     try {
61361       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
61362     } catch (std::out_of_range& e) {
61363       {
61364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61365       };
61366     } catch (std::exception& e) {
61367       {
61368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61369       };
61370     } catch (...) {
61371       {
61372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61373       };
61374     }
61375   }
61376 }
61377
61378
61379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
61380   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61381   Dali::Toolkit::StyleManager arg2 ;
61382   Dali::StyleChange::Type arg3 ;
61383   Dali::Toolkit::StyleManager *argp2 ;
61384
61385   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61386   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61387   if (!argp2) {
61388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61389     return ;
61390   }
61391   arg2 = *argp2;
61392   arg3 = (Dali::StyleChange::Type)jarg3;
61393   {
61394     try {
61395       (arg1)->OnStyleChange(arg2,arg3);
61396     } catch (std::out_of_range& e) {
61397       {
61398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61399       };
61400     } catch (std::exception& e) {
61401       {
61402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61403       };
61404     } catch (...) {
61405       {
61406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61407       };
61408     }
61409   }
61410 }
61411
61412
61413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61414   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61415   Dali::Toolkit::StyleManager arg2 ;
61416   Dali::StyleChange::Type arg3 ;
61417   Dali::Toolkit::StyleManager *argp2 ;
61418
61419   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61420   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61421   if (!argp2) {
61422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61423     return ;
61424   }
61425   arg2 = *argp2;
61426   arg3 = (Dali::StyleChange::Type)jarg3;
61427   {
61428     try {
61429       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
61430     } catch (std::out_of_range& e) {
61431       {
61432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61433       };
61434     } catch (std::exception& e) {
61435       {
61436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61437       };
61438     } catch (...) {
61439       {
61440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61441       };
61442     }
61443   }
61444 }
61445
61446
61447 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
61448   unsigned int jresult ;
61449   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61450   bool result;
61451
61452   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61453   {
61454     try {
61455       result = (bool)(arg1)->OnAccessibilityActivated();
61456     } catch (std::out_of_range& e) {
61457       {
61458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61459       };
61460     } catch (std::exception& e) {
61461       {
61462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61463       };
61464     } catch (...) {
61465       {
61466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61467       };
61468     }
61469   }
61470   jresult = result;
61471   return jresult;
61472 }
61473
61474
61475 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
61476   unsigned int jresult ;
61477   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61478   bool result;
61479
61480   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61481   {
61482     try {
61483       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
61484     } catch (std::out_of_range& e) {
61485       {
61486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61487       };
61488     } catch (std::exception& e) {
61489       {
61490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61491       };
61492     } catch (...) {
61493       {
61494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61495       };
61496     }
61497   }
61498   jresult = result;
61499   return jresult;
61500 }
61501
61502
61503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
61504   unsigned int jresult ;
61505   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61506   Dali::PanGesture arg2 ;
61507   Dali::PanGesture *argp2 ;
61508   bool result;
61509
61510   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61511   argp2 = (Dali::PanGesture *)jarg2;
61512   if (!argp2) {
61513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61514     return 0;
61515   }
61516   arg2 = *argp2;
61517   {
61518     try {
61519       result = (bool)(arg1)->OnAccessibilityPan(arg2);
61520     } catch (std::out_of_range& e) {
61521       {
61522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61523       };
61524     } catch (std::exception& e) {
61525       {
61526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61527       };
61528     } catch (...) {
61529       {
61530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61531       };
61532     }
61533   }
61534   jresult = result;
61535   return jresult;
61536 }
61537
61538
61539 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61540   unsigned int jresult ;
61541   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61542   Dali::PanGesture arg2 ;
61543   Dali::PanGesture *argp2 ;
61544   bool result;
61545
61546   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61547   argp2 = (Dali::PanGesture *)jarg2;
61548   if (!argp2) {
61549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61550     return 0;
61551   }
61552   arg2 = *argp2;
61553   {
61554     try {
61555       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
61556     } catch (std::out_of_range& e) {
61557       {
61558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61559       };
61560     } catch (std::exception& e) {
61561       {
61562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61563       };
61564     } catch (...) {
61565       {
61566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61567       };
61568     }
61569   }
61570   jresult = result;
61571   return jresult;
61572 }
61573
61574
61575 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
61576   unsigned int jresult ;
61577   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61578   Dali::TouchEvent *arg2 = 0 ;
61579   bool result;
61580
61581   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61582   arg2 = (Dali::TouchEvent *)jarg2;
61583   if (!arg2) {
61584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61585     return 0;
61586   }
61587   {
61588     try {
61589       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
61590     } catch (std::out_of_range& e) {
61591       {
61592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61593       };
61594     } catch (std::exception& e) {
61595       {
61596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61597       };
61598     } catch (...) {
61599       {
61600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61601       };
61602     }
61603   }
61604   jresult = result;
61605   return jresult;
61606 }
61607
61608
61609 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61610   unsigned int jresult ;
61611   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61612   Dali::TouchEvent *arg2 = 0 ;
61613   bool result;
61614
61615   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61616   arg2 = (Dali::TouchEvent *)jarg2;
61617   if (!arg2) {
61618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61619     return 0;
61620   }
61621   {
61622     try {
61623       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
61624     } catch (std::out_of_range& e) {
61625       {
61626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61627       };
61628     } catch (std::exception& e) {
61629       {
61630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61631       };
61632     } catch (...) {
61633       {
61634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61635       };
61636     }
61637   }
61638   jresult = result;
61639   return jresult;
61640 }
61641
61642
61643 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
61644   unsigned int jresult ;
61645   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61646   bool arg2 ;
61647   bool result;
61648
61649   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61650   arg2 = jarg2 ? true : false;
61651   {
61652     try {
61653       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
61654     } catch (std::out_of_range& e) {
61655       {
61656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61657       };
61658     } catch (std::exception& e) {
61659       {
61660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61661       };
61662     } catch (...) {
61663       {
61664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61665       };
61666     }
61667   }
61668   jresult = result;
61669   return jresult;
61670 }
61671
61672
61673 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
61674   unsigned int jresult ;
61675   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61676   bool arg2 ;
61677   bool result;
61678
61679   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61680   arg2 = jarg2 ? true : false;
61681   {
61682     try {
61683       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
61684     } catch (std::out_of_range& e) {
61685       {
61686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61687       };
61688     } catch (std::exception& e) {
61689       {
61690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61691       };
61692     } catch (...) {
61693       {
61694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61695       };
61696     }
61697   }
61698   jresult = result;
61699   return jresult;
61700 }
61701
61702
61703 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
61704   unsigned int jresult ;
61705   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61706   bool result;
61707
61708   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61709   {
61710     try {
61711       result = (bool)(arg1)->OnAccessibilityZoom();
61712     } catch (std::out_of_range& e) {
61713       {
61714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61715       };
61716     } catch (std::exception& e) {
61717       {
61718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61719       };
61720     } catch (...) {
61721       {
61722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61723       };
61724     }
61725   }
61726   jresult = result;
61727   return jresult;
61728 }
61729
61730
61731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
61732   unsigned int jresult ;
61733   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61734   bool result;
61735
61736   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61737   {
61738     try {
61739       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
61740     } catch (std::out_of_range& e) {
61741       {
61742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61743       };
61744     } catch (std::exception& e) {
61745       {
61746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61747       };
61748     } catch (...) {
61749       {
61750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61751       };
61752     }
61753   }
61754   jresult = result;
61755   return jresult;
61756 }
61757
61758
61759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
61760   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61761
61762   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61763   {
61764     try {
61765       (arg1)->OnKeyInputFocusGained();
61766     } catch (std::out_of_range& e) {
61767       {
61768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61769       };
61770     } catch (std::exception& e) {
61771       {
61772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61773       };
61774     } catch (...) {
61775       {
61776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61777       };
61778     }
61779   }
61780 }
61781
61782
61783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
61784   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61785
61786   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61787   {
61788     try {
61789       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
61790     } catch (std::out_of_range& e) {
61791       {
61792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61793       };
61794     } catch (std::exception& e) {
61795       {
61796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61797       };
61798     } catch (...) {
61799       {
61800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61801       };
61802     }
61803   }
61804 }
61805
61806
61807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
61808   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61809
61810   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61811   {
61812     try {
61813       (arg1)->OnKeyInputFocusLost();
61814     } catch (std::out_of_range& e) {
61815       {
61816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61817       };
61818     } catch (std::exception& e) {
61819       {
61820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61821       };
61822     } catch (...) {
61823       {
61824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61825       };
61826     }
61827   }
61828 }
61829
61830
61831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
61832   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61833
61834   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61835   {
61836     try {
61837       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
61838     } catch (std::out_of_range& e) {
61839       {
61840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61841       };
61842     } catch (std::exception& e) {
61843       {
61844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61845       };
61846     } catch (...) {
61847       {
61848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61849       };
61850     }
61851   }
61852 }
61853
61854
61855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
61856   void * jresult ;
61857   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61858   Dali::Actor arg2 ;
61859   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
61860   bool arg4 ;
61861   Dali::Actor *argp2 ;
61862   Dali::Actor result;
61863
61864   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61865   argp2 = (Dali::Actor *)jarg2;
61866   if (!argp2) {
61867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61868     return 0;
61869   }
61870   arg2 = *argp2;
61871   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
61872   arg4 = jarg4 ? true : false;
61873   {
61874     try {
61875       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
61876     } catch (std::out_of_range& e) {
61877       {
61878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61879       };
61880     } catch (std::exception& e) {
61881       {
61882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61883       };
61884     } catch (...) {
61885       {
61886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61887       };
61888     }
61889   }
61890   jresult = new Dali::Actor((const Dali::Actor &)result);
61891   return jresult;
61892 }
61893
61894
61895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
61896   void * jresult ;
61897   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61898   Dali::Actor arg2 ;
61899   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
61900   bool arg4 ;
61901   Dali::Actor *argp2 ;
61902   Dali::Actor result;
61903
61904   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61905   argp2 = (Dali::Actor *)jarg2;
61906   if (!argp2) {
61907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61908     return 0;
61909   }
61910   arg2 = *argp2;
61911   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
61912   arg4 = jarg4 ? true : false;
61913   {
61914     try {
61915       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
61916     } catch (std::out_of_range& e) {
61917       {
61918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61919       };
61920     } catch (std::exception& e) {
61921       {
61922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61923       };
61924     } catch (...) {
61925       {
61926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61927       };
61928     }
61929   }
61930   jresult = new Dali::Actor((const Dali::Actor &)result);
61931   return jresult;
61932 }
61933
61934
61935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
61936   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61937   Dali::Actor arg2 ;
61938   Dali::Actor *argp2 ;
61939
61940   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61941   argp2 = (Dali::Actor *)jarg2;
61942   if (!argp2) {
61943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61944     return ;
61945   }
61946   arg2 = *argp2;
61947   {
61948     try {
61949       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
61950     } catch (std::out_of_range& e) {
61951       {
61952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61953       };
61954     } catch (std::exception& e) {
61955       {
61956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61957       };
61958     } catch (...) {
61959       {
61960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61961       };
61962     }
61963   }
61964 }
61965
61966
61967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61968   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61969   Dali::Actor arg2 ;
61970   Dali::Actor *argp2 ;
61971
61972   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61973   argp2 = (Dali::Actor *)jarg2;
61974   if (!argp2) {
61975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61976     return ;
61977   }
61978   arg2 = *argp2;
61979   {
61980     try {
61981       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
61982     } catch (std::out_of_range& e) {
61983       {
61984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61985       };
61986     } catch (std::exception& e) {
61987       {
61988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61989       };
61990     } catch (...) {
61991       {
61992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61993       };
61994     }
61995   }
61996 }
61997
61998
61999 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
62000   unsigned int jresult ;
62001   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62002   bool result;
62003
62004   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62005   {
62006     try {
62007       result = (bool)(arg1)->OnKeyboardEnter();
62008     } catch (std::out_of_range& e) {
62009       {
62010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62011       };
62012     } catch (std::exception& e) {
62013       {
62014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62015       };
62016     } catch (...) {
62017       {
62018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62019       };
62020     }
62021   }
62022   jresult = result;
62023   return jresult;
62024 }
62025
62026
62027 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
62028   unsigned int jresult ;
62029   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62030   bool result;
62031
62032   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62033   {
62034     try {
62035       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
62036     } catch (std::out_of_range& e) {
62037       {
62038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62039       };
62040     } catch (std::exception& e) {
62041       {
62042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62043       };
62044     } catch (...) {
62045       {
62046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62047       };
62048     }
62049   }
62050   jresult = result;
62051   return jresult;
62052 }
62053
62054
62055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
62056   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62057   Dali::PinchGesture *arg2 = 0 ;
62058
62059   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62060   arg2 = (Dali::PinchGesture *)jarg2;
62061   if (!arg2) {
62062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62063     return ;
62064   }
62065   {
62066     try {
62067       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
62068     } catch (std::out_of_range& e) {
62069       {
62070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62071       };
62072     } catch (std::exception& e) {
62073       {
62074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62075       };
62076     } catch (...) {
62077       {
62078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62079       };
62080     }
62081   }
62082 }
62083
62084
62085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62086   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62087   Dali::PinchGesture *arg2 = 0 ;
62088
62089   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62090   arg2 = (Dali::PinchGesture *)jarg2;
62091   if (!arg2) {
62092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62093     return ;
62094   }
62095   {
62096     try {
62097       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
62098     } catch (std::out_of_range& e) {
62099       {
62100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62101       };
62102     } catch (std::exception& e) {
62103       {
62104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62105       };
62106     } catch (...) {
62107       {
62108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62109       };
62110     }
62111   }
62112 }
62113
62114
62115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
62116   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62117   Dali::PanGesture *arg2 = 0 ;
62118
62119   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62120   arg2 = (Dali::PanGesture *)jarg2;
62121   if (!arg2) {
62122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62123     return ;
62124   }
62125   {
62126     try {
62127       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
62128     } catch (std::out_of_range& e) {
62129       {
62130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62131       };
62132     } catch (std::exception& e) {
62133       {
62134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62135       };
62136     } catch (...) {
62137       {
62138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62139       };
62140     }
62141   }
62142 }
62143
62144
62145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62146   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62147   Dali::PanGesture *arg2 = 0 ;
62148
62149   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62150   arg2 = (Dali::PanGesture *)jarg2;
62151   if (!arg2) {
62152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62153     return ;
62154   }
62155   {
62156     try {
62157       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
62158     } catch (std::out_of_range& e) {
62159       {
62160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62161       };
62162     } catch (std::exception& e) {
62163       {
62164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62165       };
62166     } catch (...) {
62167       {
62168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62169       };
62170     }
62171   }
62172 }
62173
62174
62175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
62176   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62177   Dali::TapGesture *arg2 = 0 ;
62178
62179   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62180   arg2 = (Dali::TapGesture *)jarg2;
62181   if (!arg2) {
62182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62183     return ;
62184   }
62185   {
62186     try {
62187       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
62188     } catch (std::out_of_range& e) {
62189       {
62190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62191       };
62192     } catch (std::exception& e) {
62193       {
62194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62195       };
62196     } catch (...) {
62197       {
62198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62199       };
62200     }
62201   }
62202 }
62203
62204
62205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62206   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62207   Dali::TapGesture *arg2 = 0 ;
62208
62209   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62210   arg2 = (Dali::TapGesture *)jarg2;
62211   if (!arg2) {
62212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62213     return ;
62214   }
62215   {
62216     try {
62217       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
62218     } catch (std::out_of_range& e) {
62219       {
62220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62221       };
62222     } catch (std::exception& e) {
62223       {
62224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62225       };
62226     } catch (...) {
62227       {
62228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62229       };
62230     }
62231   }
62232 }
62233
62234
62235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
62236   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62237   Dali::LongPressGesture *arg2 = 0 ;
62238
62239   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62240   arg2 = (Dali::LongPressGesture *)jarg2;
62241   if (!arg2) {
62242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62243     return ;
62244   }
62245   {
62246     try {
62247       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
62248     } catch (std::out_of_range& e) {
62249       {
62250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62251       };
62252     } catch (std::exception& e) {
62253       {
62254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62255       };
62256     } catch (...) {
62257       {
62258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62259       };
62260     }
62261   }
62262 }
62263
62264
62265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62266   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62267   Dali::LongPressGesture *arg2 = 0 ;
62268
62269   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62270   arg2 = (Dali::LongPressGesture *)jarg2;
62271   if (!arg2) {
62272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62273     return ;
62274   }
62275   {
62276     try {
62277       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
62278     } catch (std::out_of_range& e) {
62279       {
62280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62281       };
62282     } catch (std::exception& e) {
62283       {
62284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62285       };
62286     } catch (...) {
62287       {
62288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62289       };
62290     }
62291   }
62292 }
62293
62294
62295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
62296   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62297   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62298   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62299
62300   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62301   arg2 = (Dali::SlotObserver *)jarg2;
62302   arg3 = (Dali::CallbackBase *)jarg3;
62303   {
62304     try {
62305       (arg1)->SignalConnected(arg2,arg3);
62306     } catch (std::out_of_range& e) {
62307       {
62308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62309       };
62310     } catch (std::exception& e) {
62311       {
62312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62313       };
62314     } catch (...) {
62315       {
62316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62317       };
62318     }
62319   }
62320 }
62321
62322
62323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62324   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62325   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62326   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62327
62328   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62329   arg2 = (Dali::SlotObserver *)jarg2;
62330   arg3 = (Dali::CallbackBase *)jarg3;
62331   {
62332     try {
62333       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
62334     } catch (std::out_of_range& e) {
62335       {
62336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62337       };
62338     } catch (std::exception& e) {
62339       {
62340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62341       };
62342     } catch (...) {
62343       {
62344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62345       };
62346     }
62347   }
62348 }
62349
62350
62351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
62352   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62353   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62354   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62355
62356   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62357   arg2 = (Dali::SlotObserver *)jarg2;
62358   arg3 = (Dali::CallbackBase *)jarg3;
62359   {
62360     try {
62361       (arg1)->SignalDisconnected(arg2,arg3);
62362     } catch (std::out_of_range& e) {
62363       {
62364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62365       };
62366     } catch (std::exception& e) {
62367       {
62368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62369       };
62370     } catch (...) {
62371       {
62372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62373       };
62374     }
62375   }
62376 }
62377
62378
62379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62380   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62381   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62382   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62383
62384   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62385   arg2 = (Dali::SlotObserver *)jarg2;
62386   arg3 = (Dali::CallbackBase *)jarg3;
62387   {
62388     try {
62389       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
62390     } catch (std::out_of_range& e) {
62391       {
62392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62393       };
62394     } catch (std::exception& e) {
62395       {
62396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62397       };
62398     } catch (...) {
62399       {
62400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62401       };
62402     }
62403   }
62404 }
62405
62406
62407 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) {
62408   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
62409   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
62410   if (director) {
62411     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);
62412   }
62413 }
62414
62415
62416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
62417   void * jresult ;
62418   Dali::Toolkit::Control *arg1 = 0 ;
62419   Dali::Toolkit::Internal::Control *result = 0 ;
62420
62421   arg1 = (Dali::Toolkit::Control *)jarg1;
62422   if (!arg1) {
62423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
62424     return 0;
62425   }
62426   {
62427     try {
62428       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
62429     } catch (std::out_of_range& e) {
62430       {
62431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62432       };
62433     } catch (std::exception& e) {
62434       {
62435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62436       };
62437     } catch (...) {
62438       {
62439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62440       };
62441     }
62442   }
62443   jresult = (void *)result;
62444   return jresult;
62445 }
62446
62447
62448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
62449   int jresult ;
62450   int result;
62451
62452   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
62453   jresult = (int)result;
62454   return jresult;
62455 }
62456
62457
62458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
62459   int jresult ;
62460   int result;
62461
62462   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
62463   jresult = (int)result;
62464   return jresult;
62465 }
62466
62467
62468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
62469   int jresult ;
62470   int result;
62471
62472   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
62473   jresult = (int)result;
62474   return jresult;
62475 }
62476
62477
62478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
62479   int jresult ;
62480   int result;
62481
62482   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
62483   jresult = (int)result;
62484   return jresult;
62485 }
62486
62487
62488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
62489   int jresult ;
62490   int result;
62491
62492   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
62493   jresult = (int)result;
62494   return jresult;
62495 }
62496
62497
62498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
62499   void * jresult ;
62500   Dali::Toolkit::Control::Property *result = 0 ;
62501
62502   {
62503     try {
62504       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
62505     } catch (std::out_of_range& e) {
62506       {
62507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62508       };
62509     } catch (std::exception& e) {
62510       {
62511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62512       };
62513     } catch (...) {
62514       {
62515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62516       };
62517     }
62518   }
62519   jresult = (void *)result;
62520   return jresult;
62521 }
62522
62523
62524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
62525   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
62526
62527   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
62528   {
62529     try {
62530       delete arg1;
62531     } catch (std::out_of_range& e) {
62532       {
62533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62534       };
62535     } catch (std::exception& e) {
62536       {
62537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62538       };
62539     } catch (...) {
62540       {
62541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62542       };
62543     }
62544   }
62545 }
62546
62547
62548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
62549   void * jresult ;
62550   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
62551
62552   {
62553     try {
62554       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
62555     } catch (std::out_of_range& e) {
62556       {
62557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62558       };
62559     } catch (std::exception& e) {
62560       {
62561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62562       };
62563     } catch (...) {
62564       {
62565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62566       };
62567     }
62568   }
62569   jresult = (void *)result;
62570   return jresult;
62571 }
62572
62573
62574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
62575   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
62576
62577   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
62578   {
62579     try {
62580       delete arg1;
62581     } catch (std::out_of_range& e) {
62582       {
62583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62584       };
62585     } catch (std::exception& e) {
62586       {
62587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62588       };
62589     } catch (...) {
62590       {
62591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62592       };
62593     }
62594   }
62595 }
62596
62597
62598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
62599   void * jresult ;
62600   Dali::Toolkit::Control result;
62601
62602   {
62603     try {
62604       result = Dali::Toolkit::Control::New();
62605     } catch (std::out_of_range& e) {
62606       {
62607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62608       };
62609     } catch (std::exception& e) {
62610       {
62611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62612       };
62613     } catch (...) {
62614       {
62615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62616       };
62617     }
62618   }
62619   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62620   return jresult;
62621 }
62622
62623
62624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
62625   void * jresult ;
62626   Dali::Toolkit::Control *result = 0 ;
62627
62628   {
62629     try {
62630       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
62631     } catch (std::out_of_range& e) {
62632       {
62633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62634       };
62635     } catch (std::exception& e) {
62636       {
62637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62638       };
62639     } catch (...) {
62640       {
62641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62642       };
62643     }
62644   }
62645   jresult = (void *)result;
62646   return jresult;
62647 }
62648
62649
62650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
62651   void * jresult ;
62652   Dali::Toolkit::Control *arg1 = 0 ;
62653   Dali::Toolkit::Control *result = 0 ;
62654
62655   arg1 = (Dali::Toolkit::Control *)jarg1;
62656   if (!arg1) {
62657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
62658     return 0;
62659   }
62660   {
62661     try {
62662       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
62663     } catch (std::out_of_range& e) {
62664       {
62665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62666       };
62667     } catch (std::exception& e) {
62668       {
62669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62670       };
62671     } catch (...) {
62672       {
62673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62674       };
62675     }
62676   }
62677   jresult = (void *)result;
62678   return jresult;
62679 }
62680
62681
62682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
62683   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62684
62685   arg1 = (Dali::Toolkit::Control *)jarg1;
62686   {
62687     try {
62688       delete arg1;
62689     } catch (std::out_of_range& e) {
62690       {
62691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62692       };
62693     } catch (std::exception& e) {
62694       {
62695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62696       };
62697     } catch (...) {
62698       {
62699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62700       };
62701     }
62702   }
62703 }
62704
62705
62706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
62707   void * jresult ;
62708   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62709   Dali::Toolkit::Control *arg2 = 0 ;
62710   Dali::Toolkit::Control *result = 0 ;
62711
62712   arg1 = (Dali::Toolkit::Control *)jarg1;
62713   arg2 = (Dali::Toolkit::Control *)jarg2;
62714   if (!arg2) {
62715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
62716     return 0;
62717   }
62718   {
62719     try {
62720       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
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_View_DownCast(void * jarg1) {
62741   void * jresult ;
62742   Dali::BaseHandle arg1 ;
62743   Dali::BaseHandle *argp1 ;
62744   Dali::Toolkit::Control result;
62745
62746   argp1 = (Dali::BaseHandle *)jarg1;
62747   if (!argp1) {
62748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62749     return 0;
62750   }
62751   arg1 = *argp1;
62752   {
62753     try {
62754       result = Dali::Toolkit::Control::DownCast(arg1);
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 = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62770   return jresult;
62771 }
62772
62773
62774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
62775   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62776
62777   arg1 = (Dali::Toolkit::Control *)jarg1;
62778   {
62779     try {
62780       (arg1)->SetKeyInputFocus();
62781     } catch (std::out_of_range& e) {
62782       {
62783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62784       };
62785     } catch (std::exception& e) {
62786       {
62787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62788       };
62789     } catch (...) {
62790       {
62791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62792       };
62793     }
62794   }
62795 }
62796
62797
62798 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
62799   unsigned int jresult ;
62800   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62801   bool result;
62802
62803   arg1 = (Dali::Toolkit::Control *)jarg1;
62804   {
62805     try {
62806       result = (bool)(arg1)->HasKeyInputFocus();
62807     } catch (std::out_of_range& e) {
62808       {
62809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62810       };
62811     } catch (std::exception& e) {
62812       {
62813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62814       };
62815     } catch (...) {
62816       {
62817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62818       };
62819     }
62820   }
62821   jresult = result;
62822   return jresult;
62823 }
62824
62825
62826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
62827   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62828
62829   arg1 = (Dali::Toolkit::Control *)jarg1;
62830   {
62831     try {
62832       (arg1)->ClearKeyInputFocus();
62833     } catch (std::out_of_range& e) {
62834       {
62835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62836       };
62837     } catch (std::exception& e) {
62838       {
62839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62840       };
62841     } catch (...) {
62842       {
62843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62844       };
62845     }
62846   }
62847 }
62848
62849
62850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
62851   void * jresult ;
62852   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62853   Dali::PinchGestureDetector result;
62854
62855   arg1 = (Dali::Toolkit::Control *)jarg1;
62856   {
62857     try {
62858       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
62859     } catch (std::out_of_range& e) {
62860       {
62861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62862       };
62863     } catch (std::exception& e) {
62864       {
62865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62866       };
62867     } catch (...) {
62868       {
62869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62870       };
62871     }
62872   }
62873   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
62874   return jresult;
62875 }
62876
62877
62878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
62879   void * jresult ;
62880   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62881   Dali::PanGestureDetector result;
62882
62883   arg1 = (Dali::Toolkit::Control *)jarg1;
62884   {
62885     try {
62886       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
62887     } catch (std::out_of_range& e) {
62888       {
62889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62890       };
62891     } catch (std::exception& e) {
62892       {
62893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62894       };
62895     } catch (...) {
62896       {
62897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62898       };
62899     }
62900   }
62901   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
62902   return jresult;
62903 }
62904
62905
62906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
62907   void * jresult ;
62908   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62909   Dali::TapGestureDetector result;
62910
62911   arg1 = (Dali::Toolkit::Control *)jarg1;
62912   {
62913     try {
62914       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
62915     } catch (std::out_of_range& e) {
62916       {
62917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62918       };
62919     } catch (std::exception& e) {
62920       {
62921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62922       };
62923     } catch (...) {
62924       {
62925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62926       };
62927     }
62928   }
62929   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
62930   return jresult;
62931 }
62932
62933
62934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
62935   void * jresult ;
62936   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62937   Dali::LongPressGestureDetector result;
62938
62939   arg1 = (Dali::Toolkit::Control *)jarg1;
62940   {
62941     try {
62942       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
62943     } catch (std::out_of_range& e) {
62944       {
62945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62946       };
62947     } catch (std::exception& e) {
62948       {
62949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62950       };
62951     } catch (...) {
62952       {
62953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62954       };
62955     }
62956   }
62957   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
62958   return jresult;
62959 }
62960
62961
62962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
62963   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62964   std::string *arg2 = 0 ;
62965
62966   arg1 = (Dali::Toolkit::Control *)jarg1;
62967   if (!jarg2) {
62968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62969     return ;
62970   }
62971   std::string arg2_str(jarg2);
62972   arg2 = &arg2_str;
62973   {
62974     try {
62975       (arg1)->SetStyleName((std::string const &)*arg2);
62976     } catch (std::out_of_range& e) {
62977       {
62978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62979       };
62980     } catch (std::exception& e) {
62981       {
62982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62983       };
62984     } catch (...) {
62985       {
62986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62987       };
62988     }
62989   }
62990
62991   //argout typemap for const std::string&
62992
62993 }
62994
62995
62996 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
62997   char * jresult ;
62998   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62999   std::string *result = 0 ;
63000
63001   arg1 = (Dali::Toolkit::Control *)jarg1;
63002   {
63003     try {
63004       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
63005     } catch (std::out_of_range& e) {
63006       {
63007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63008       };
63009     } catch (std::exception& e) {
63010       {
63011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63012       };
63013     } catch (...) {
63014       {
63015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63016       };
63017     }
63018   }
63019   jresult = SWIG_csharp_string_callback(result->c_str());
63020   return jresult;
63021 }
63022
63023
63024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
63025   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63026   Dali::Vector4 *arg2 = 0 ;
63027
63028   arg1 = (Dali::Toolkit::Control *)jarg1;
63029   arg2 = (Dali::Vector4 *)jarg2;
63030   if (!arg2) {
63031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63032     return ;
63033   }
63034   {
63035     try {
63036       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63037     } catch (std::out_of_range& e) {
63038       {
63039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63040       };
63041     } catch (std::exception& e) {
63042       {
63043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63044       };
63045     } catch (...) {
63046       {
63047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63048       };
63049     }
63050   }
63051 }
63052
63053
63054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
63055   void * jresult ;
63056   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63057   Dali::Vector4 result;
63058
63059   arg1 = (Dali::Toolkit::Control *)jarg1;
63060   {
63061     try {
63062       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
63063     } catch (std::out_of_range& e) {
63064       {
63065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63066       };
63067     } catch (std::exception& e) {
63068       {
63069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63070       };
63071     } catch (...) {
63072       {
63073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63074       };
63075     }
63076   }
63077   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63078   return jresult;
63079 }
63080
63081
63082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
63083   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63084   Dali::Image arg2 ;
63085   Dali::Image *argp2 ;
63086
63087   arg1 = (Dali::Toolkit::Control *)jarg1;
63088   argp2 = (Dali::Image *)jarg2;
63089   if (!argp2) {
63090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63091     return ;
63092   }
63093   arg2 = *argp2;
63094   {
63095     try {
63096       (arg1)->SetBackgroundImage(arg2);
63097     } catch (std::out_of_range& e) {
63098       {
63099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63100       };
63101     } catch (std::exception& e) {
63102       {
63103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63104       };
63105     } catch (...) {
63106       {
63107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63108       };
63109     }
63110   }
63111 }
63112
63113
63114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
63115   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63116
63117   arg1 = (Dali::Toolkit::Control *)jarg1;
63118   {
63119     try {
63120       (arg1)->ClearBackground();
63121     } catch (std::out_of_range& e) {
63122       {
63123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63124       };
63125     } catch (std::exception& e) {
63126       {
63127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63128       };
63129     } catch (...) {
63130       {
63131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63132       };
63133     }
63134   }
63135 }
63136
63137
63138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
63139   void * jresult ;
63140   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63141   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63142
63143   arg1 = (Dali::Toolkit::Control *)jarg1;
63144   {
63145     try {
63146       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63147     } catch (std::out_of_range& e) {
63148       {
63149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63150       };
63151     } catch (std::exception& e) {
63152       {
63153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63154       };
63155     } catch (...) {
63156       {
63157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63158       };
63159     }
63160   }
63161   jresult = (void *)result;
63162   return jresult;
63163 }
63164
63165
63166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
63167   void * jresult ;
63168   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63169   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63170
63171   arg1 = (Dali::Toolkit::Control *)jarg1;
63172   {
63173     try {
63174       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63175     } catch (std::out_of_range& e) {
63176       {
63177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63178       };
63179     } catch (std::exception& e) {
63180       {
63181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63182       };
63183     } catch (...) {
63184       {
63185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63186       };
63187     }
63188   }
63189   jresult = (void *)result;
63190   return jresult;
63191 }
63192
63193
63194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
63195   void * jresult ;
63196   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63197   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63198
63199   arg1 = (Dali::Toolkit::Control *)jarg1;
63200   {
63201     try {
63202       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63203     } catch (std::out_of_range& e) {
63204       {
63205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63206       };
63207     } catch (std::exception& e) {
63208       {
63209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63210       };
63211     } catch (...) {
63212       {
63213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63214       };
63215     }
63216   }
63217   jresult = (void *)result;
63218   return jresult;
63219 }
63220
63221
63222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
63223   void * jresult ;
63224   Dali::Toolkit::Internal::Control *arg1 = 0 ;
63225   Dali::Toolkit::Control *result = 0 ;
63226
63227   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63228   if (!arg1) {
63229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
63230     return 0;
63231   }
63232   {
63233     try {
63234       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
63235     } catch (std::out_of_range& e) {
63236       {
63237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63238       };
63239     } catch (std::exception& e) {
63240       {
63241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63242       };
63243     } catch (...) {
63244       {
63245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63246       };
63247     }
63248   }
63249   jresult = (void *)result;
63250   return jresult;
63251 }
63252
63253
63254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
63255   void * jresult ;
63256   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
63257
63258   {
63259     try {
63260       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
63261     } catch (std::out_of_range& e) {
63262       {
63263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63264       };
63265     } catch (std::exception& e) {
63266       {
63267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63268       };
63269     } catch (...) {
63270       {
63271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63272       };
63273     }
63274   }
63275   jresult = (void *)result;
63276   return jresult;
63277 }
63278
63279
63280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
63281   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63282
63283   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63284   {
63285     try {
63286       delete arg1;
63287     } catch (std::out_of_range& e) {
63288       {
63289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63290       };
63291     } catch (std::exception& e) {
63292       {
63293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63294       };
63295     } catch (...) {
63296       {
63297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63298       };
63299     }
63300   }
63301 }
63302
63303
63304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
63305   void * jresult ;
63306   Dali::Toolkit::KeyInputFocusManager result;
63307
63308   {
63309     try {
63310       result = Dali::Toolkit::KeyInputFocusManager::Get();
63311     } catch (std::out_of_range& e) {
63312       {
63313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63314       };
63315     } catch (std::exception& e) {
63316       {
63317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63318       };
63319     } catch (...) {
63320       {
63321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63322       };
63323     }
63324   }
63325   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
63326   return jresult;
63327 }
63328
63329
63330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
63331   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63332   Dali::Toolkit::Control arg2 ;
63333   Dali::Toolkit::Control *argp2 ;
63334
63335   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63336   argp2 = (Dali::Toolkit::Control *)jarg2;
63337   if (!argp2) {
63338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
63339     return ;
63340   }
63341   arg2 = *argp2;
63342   {
63343     try {
63344       (arg1)->SetFocus(arg2);
63345     } catch (std::out_of_range& e) {
63346       {
63347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63348       };
63349     } catch (std::exception& e) {
63350       {
63351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63352       };
63353     } catch (...) {
63354       {
63355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63356       };
63357     }
63358   }
63359 }
63360
63361
63362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
63363   void * jresult ;
63364   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63365   Dali::Toolkit::Control result;
63366
63367   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63368   {
63369     try {
63370       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
63371     } catch (std::out_of_range& e) {
63372       {
63373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63374       };
63375     } catch (std::exception& e) {
63376       {
63377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63378       };
63379     } catch (...) {
63380       {
63381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63382       };
63383     }
63384   }
63385   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63386   return jresult;
63387 }
63388
63389
63390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
63391   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63392   Dali::Toolkit::Control arg2 ;
63393   Dali::Toolkit::Control *argp2 ;
63394
63395   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63396   argp2 = (Dali::Toolkit::Control *)jarg2;
63397   if (!argp2) {
63398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
63399     return ;
63400   }
63401   arg2 = *argp2;
63402   {
63403     try {
63404       (arg1)->RemoveFocus(arg2);
63405     } catch (std::out_of_range& e) {
63406       {
63407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63408       };
63409     } catch (std::exception& e) {
63410       {
63411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63412       };
63413     } catch (...) {
63414       {
63415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63416       };
63417     }
63418   }
63419 }
63420
63421
63422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
63423   void * jresult ;
63424   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63425   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
63426
63427   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63428   {
63429     try {
63430       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
63431     } catch (std::out_of_range& e) {
63432       {
63433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63434       };
63435     } catch (std::exception& e) {
63436       {
63437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63438       };
63439     } catch (...) {
63440       {
63441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63442       };
63443     }
63444   }
63445   jresult = (void *)result;
63446   return jresult;
63447 }
63448
63449
63450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
63451   void * jresult ;
63452   Dali::Toolkit::Alignment::Padding *result = 0 ;
63453
63454   {
63455     try {
63456       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
63457     } catch (std::out_of_range& e) {
63458       {
63459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63460       };
63461     } catch (std::exception& e) {
63462       {
63463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63464       };
63465     } catch (...) {
63466       {
63467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63468       };
63469     }
63470   }
63471   jresult = (void *)result;
63472   return jresult;
63473 }
63474
63475
63476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
63477   void * jresult ;
63478   float arg1 ;
63479   float arg2 ;
63480   float arg3 ;
63481   float arg4 ;
63482   Dali::Toolkit::Alignment::Padding *result = 0 ;
63483
63484   arg1 = (float)jarg1;
63485   arg2 = (float)jarg2;
63486   arg3 = (float)jarg3;
63487   arg4 = (float)jarg4;
63488   {
63489     try {
63490       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
63491     } catch (std::out_of_range& e) {
63492       {
63493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63494       };
63495     } catch (std::exception& e) {
63496       {
63497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63498       };
63499     } catch (...) {
63500       {
63501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63502       };
63503     }
63504   }
63505   jresult = (void *)result;
63506   return jresult;
63507 }
63508
63509
63510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
63511   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63512   float arg2 ;
63513
63514   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63515   arg2 = (float)jarg2;
63516   if (arg1) (arg1)->left = arg2;
63517 }
63518
63519
63520 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
63521   float jresult ;
63522   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63523   float result;
63524
63525   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63526   result = (float) ((arg1)->left);
63527   jresult = result;
63528   return jresult;
63529 }
63530
63531
63532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
63533   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63534   float arg2 ;
63535
63536   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63537   arg2 = (float)jarg2;
63538   if (arg1) (arg1)->right = arg2;
63539 }
63540
63541
63542 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
63543   float jresult ;
63544   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63545   float result;
63546
63547   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63548   result = (float) ((arg1)->right);
63549   jresult = result;
63550   return jresult;
63551 }
63552
63553
63554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
63555   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63556   float arg2 ;
63557
63558   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63559   arg2 = (float)jarg2;
63560   if (arg1) (arg1)->top = arg2;
63561 }
63562
63563
63564 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
63565   float jresult ;
63566   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63567   float result;
63568
63569   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63570   result = (float) ((arg1)->top);
63571   jresult = result;
63572   return jresult;
63573 }
63574
63575
63576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
63577   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63578   float arg2 ;
63579
63580   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63581   arg2 = (float)jarg2;
63582   if (arg1) (arg1)->bottom = arg2;
63583 }
63584
63585
63586 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
63587   float jresult ;
63588   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63589   float result;
63590
63591   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63592   result = (float) ((arg1)->bottom);
63593   jresult = result;
63594   return jresult;
63595 }
63596
63597
63598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
63599   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63600
63601   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63602   {
63603     try {
63604       delete arg1;
63605     } catch (std::out_of_range& e) {
63606       {
63607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63608       };
63609     } catch (std::exception& e) {
63610       {
63611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63612       };
63613     } catch (...) {
63614       {
63615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63616       };
63617     }
63618   }
63619 }
63620
63621
63622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
63623   void * jresult ;
63624   Dali::Toolkit::Alignment *result = 0 ;
63625
63626   {
63627     try {
63628       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
63629     } catch (std::out_of_range& e) {
63630       {
63631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63632       };
63633     } catch (std::exception& e) {
63634       {
63635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63636       };
63637     } catch (...) {
63638       {
63639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63640       };
63641     }
63642   }
63643   jresult = (void *)result;
63644   return jresult;
63645 }
63646
63647
63648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
63649   void * jresult ;
63650   Dali::Toolkit::Alignment::Type arg1 ;
63651   Dali::Toolkit::Alignment::Type arg2 ;
63652   Dali::Toolkit::Alignment result;
63653
63654   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
63655   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
63656   {
63657     try {
63658       result = Dali::Toolkit::Alignment::New(arg1,arg2);
63659     } catch (std::out_of_range& e) {
63660       {
63661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63662       };
63663     } catch (std::exception& e) {
63664       {
63665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63666       };
63667     } catch (...) {
63668       {
63669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63670       };
63671     }
63672   }
63673   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63674   return jresult;
63675 }
63676
63677
63678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
63679   void * jresult ;
63680   Dali::Toolkit::Alignment::Type arg1 ;
63681   Dali::Toolkit::Alignment result;
63682
63683   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
63684   {
63685     try {
63686       result = Dali::Toolkit::Alignment::New(arg1);
63687     } catch (std::out_of_range& e) {
63688       {
63689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63690       };
63691     } catch (std::exception& e) {
63692       {
63693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63694       };
63695     } catch (...) {
63696       {
63697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63698       };
63699     }
63700   }
63701   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63702   return jresult;
63703 }
63704
63705
63706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
63707   void * jresult ;
63708   Dali::Toolkit::Alignment result;
63709
63710   {
63711     try {
63712       result = Dali::Toolkit::Alignment::New();
63713     } catch (std::out_of_range& e) {
63714       {
63715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63716       };
63717     } catch (std::exception& e) {
63718       {
63719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63720       };
63721     } catch (...) {
63722       {
63723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63724       };
63725     }
63726   }
63727   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63728   return jresult;
63729 }
63730
63731
63732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
63733   void * jresult ;
63734   Dali::Toolkit::Alignment *arg1 = 0 ;
63735   Dali::Toolkit::Alignment *result = 0 ;
63736
63737   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63738   if (!arg1) {
63739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
63740     return 0;
63741   }
63742   {
63743     try {
63744       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
63745     } catch (std::out_of_range& e) {
63746       {
63747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63748       };
63749     } catch (std::exception& e) {
63750       {
63751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63752       };
63753     } catch (...) {
63754       {
63755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63756       };
63757     }
63758   }
63759   jresult = (void *)result;
63760   return jresult;
63761 }
63762
63763
63764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
63765   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63766
63767   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63768   {
63769     try {
63770       delete arg1;
63771     } catch (std::out_of_range& e) {
63772       {
63773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63774       };
63775     } catch (std::exception& e) {
63776       {
63777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63778       };
63779     } catch (...) {
63780       {
63781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63782       };
63783     }
63784   }
63785 }
63786
63787
63788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
63789   void * jresult ;
63790   Dali::BaseHandle arg1 ;
63791   Dali::BaseHandle *argp1 ;
63792   Dali::Toolkit::Alignment result;
63793
63794   argp1 = (Dali::BaseHandle *)jarg1;
63795   if (!argp1) {
63796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63797     return 0;
63798   }
63799   arg1 = *argp1;
63800   {
63801     try {
63802       result = Dali::Toolkit::Alignment::DownCast(arg1);
63803     } catch (std::out_of_range& e) {
63804       {
63805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63806       };
63807     } catch (std::exception& e) {
63808       {
63809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63810       };
63811     } catch (...) {
63812       {
63813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63814       };
63815     }
63816   }
63817   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63818   return jresult;
63819 }
63820
63821
63822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
63823   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63824   Dali::Toolkit::Alignment::Type arg2 ;
63825
63826   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63827   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
63828   {
63829     try {
63830       (arg1)->SetAlignmentType(arg2);
63831     } catch (std::out_of_range& e) {
63832       {
63833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63834       };
63835     } catch (std::exception& e) {
63836       {
63837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63838       };
63839     } catch (...) {
63840       {
63841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63842       };
63843     }
63844   }
63845 }
63846
63847
63848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
63849   int jresult ;
63850   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63851   Dali::Toolkit::Alignment::Type result;
63852
63853   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63854   {
63855     try {
63856       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
63857     } catch (std::out_of_range& e) {
63858       {
63859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63860       };
63861     } catch (std::exception& e) {
63862       {
63863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63864       };
63865     } catch (...) {
63866       {
63867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63868       };
63869     }
63870   }
63871   jresult = (int)result;
63872   return jresult;
63873 }
63874
63875
63876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
63877   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63878   Dali::Toolkit::Alignment::Scaling arg2 ;
63879
63880   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63881   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
63882   {
63883     try {
63884       (arg1)->SetScaling(arg2);
63885     } catch (std::out_of_range& e) {
63886       {
63887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63888       };
63889     } catch (std::exception& e) {
63890       {
63891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63892       };
63893     } catch (...) {
63894       {
63895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63896       };
63897     }
63898   }
63899 }
63900
63901
63902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
63903   int jresult ;
63904   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63905   Dali::Toolkit::Alignment::Scaling result;
63906
63907   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63908   {
63909     try {
63910       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
63911     } catch (std::out_of_range& e) {
63912       {
63913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63914       };
63915     } catch (std::exception& e) {
63916       {
63917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63918       };
63919     } catch (...) {
63920       {
63921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63922       };
63923     }
63924   }
63925   jresult = (int)result;
63926   return jresult;
63927 }
63928
63929
63930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
63931   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63932   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
63933
63934   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63935   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
63936   if (!arg2) {
63937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
63938     return ;
63939   }
63940   {
63941     try {
63942       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
63943     } catch (std::out_of_range& e) {
63944       {
63945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63946       };
63947     } catch (std::exception& e) {
63948       {
63949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63950       };
63951     } catch (...) {
63952       {
63953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63954       };
63955     }
63956   }
63957 }
63958
63959
63960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
63961   void * jresult ;
63962   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63963   Dali::Toolkit::Alignment::Padding *result = 0 ;
63964
63965   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63966   {
63967     try {
63968       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
63969     } catch (std::out_of_range& e) {
63970       {
63971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63972       };
63973     } catch (std::exception& e) {
63974       {
63975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63976       };
63977     } catch (...) {
63978       {
63979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63980       };
63981     }
63982   }
63983   jresult = (void *)result;
63984   return jresult;
63985 }
63986
63987
63988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
63989   void * jresult ;
63990   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63991   Dali::Toolkit::Alignment *arg2 = 0 ;
63992   Dali::Toolkit::Alignment *result = 0 ;
63993
63994   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63995   arg2 = (Dali::Toolkit::Alignment *)jarg2;
63996   if (!arg2) {
63997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
63998     return 0;
63999   }
64000   {
64001     try {
64002       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
64003     } catch (std::out_of_range& e) {
64004       {
64005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64006       };
64007     } catch (std::exception& e) {
64008       {
64009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64010       };
64011     } catch (...) {
64012       {
64013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64014       };
64015     }
64016   }
64017   jresult = (void *)result;
64018   return jresult;
64019 }
64020
64021
64022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
64023   int jresult ;
64024   int result;
64025
64026   result = (int)Dali::Toolkit::Button::Property::DISABLED;
64027   jresult = (int)result;
64028   return jresult;
64029 }
64030
64031
64032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
64033   int jresult ;
64034   int result;
64035
64036   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
64037   jresult = (int)result;
64038   return jresult;
64039 }
64040
64041
64042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
64043   int jresult ;
64044   int result;
64045
64046   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
64047   jresult = (int)result;
64048   return jresult;
64049 }
64050
64051
64052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
64053   int jresult ;
64054   int result;
64055
64056   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
64057   jresult = (int)result;
64058   return jresult;
64059 }
64060
64061
64062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
64063   int jresult ;
64064   int result;
64065
64066   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
64067   jresult = (int)result;
64068   return jresult;
64069 }
64070
64071
64072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
64073   int jresult ;
64074   int result;
64075
64076   result = (int)Dali::Toolkit::Button::Property::SELECTED;
64077   jresult = (int)result;
64078   return jresult;
64079 }
64080
64081
64082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_STATE_IMAGE_get() {
64083   int jresult ;
64084   int result;
64085
64086   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_STATE_IMAGE;
64087   jresult = (int)result;
64088   return jresult;
64089 }
64090
64091
64092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_STATE_IMAGE_get() {
64093   int jresult ;
64094   int result;
64095
64096   result = (int)Dali::Toolkit::Button::Property::SELECTED_STATE_IMAGE;
64097   jresult = (int)result;
64098   return jresult;
64099 }
64100
64101
64102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_STATE_IMAGE_get() {
64103   int jresult ;
64104   int result;
64105
64106   result = (int)Dali::Toolkit::Button::Property::DISABLED_STATE_IMAGE;
64107   jresult = (int)result;
64108   return jresult;
64109 }
64110
64111
64112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
64113   int jresult ;
64114   int result;
64115
64116   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
64117   jresult = (int)result;
64118   return jresult;
64119 }
64120
64121
64122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
64123   int jresult ;
64124   int result;
64125
64126   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
64127   jresult = (int)result;
64128   return jresult;
64129 }
64130
64131
64132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
64133   int jresult ;
64134   int result;
64135
64136   result = (int)Dali::Toolkit::Button::Property::LABEL;
64137   jresult = (int)result;
64138   return jresult;
64139 }
64140
64141
64142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
64143   int jresult ;
64144   int result;
64145
64146   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
64147   jresult = (int)result;
64148   return jresult;
64149 }
64150
64151
64152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
64153   void * jresult ;
64154   Dali::Toolkit::Button::Property *result = 0 ;
64155
64156   {
64157     try {
64158       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
64159     } catch (std::out_of_range& e) {
64160       {
64161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64162       };
64163     } catch (std::exception& e) {
64164       {
64165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64166       };
64167     } catch (...) {
64168       {
64169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64170       };
64171     }
64172   }
64173   jresult = (void *)result;
64174   return jresult;
64175 }
64176
64177
64178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
64179   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
64180
64181   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
64182   {
64183     try {
64184       delete arg1;
64185     } catch (std::out_of_range& e) {
64186       {
64187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64188       };
64189     } catch (std::exception& e) {
64190       {
64191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64192       };
64193     } catch (...) {
64194       {
64195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64196       };
64197     }
64198   }
64199 }
64200
64201
64202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
64203   void * jresult ;
64204   Dali::Toolkit::Button *result = 0 ;
64205
64206   {
64207     try {
64208       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
64209     } catch (std::out_of_range& e) {
64210       {
64211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64212       };
64213     } catch (std::exception& e) {
64214       {
64215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64216       };
64217     } catch (...) {
64218       {
64219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64220       };
64221     }
64222   }
64223   jresult = (void *)result;
64224   return jresult;
64225 }
64226
64227
64228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
64229   void * jresult ;
64230   Dali::Toolkit::Button *arg1 = 0 ;
64231   Dali::Toolkit::Button *result = 0 ;
64232
64233   arg1 = (Dali::Toolkit::Button *)jarg1;
64234   if (!arg1) {
64235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
64236     return 0;
64237   }
64238   {
64239     try {
64240       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
64241     } catch (std::out_of_range& e) {
64242       {
64243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64244       };
64245     } catch (std::exception& e) {
64246       {
64247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64248       };
64249     } catch (...) {
64250       {
64251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64252       };
64253     }
64254   }
64255   jresult = (void *)result;
64256   return jresult;
64257 }
64258
64259
64260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
64261   void * jresult ;
64262   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64263   Dali::Toolkit::Button *arg2 = 0 ;
64264   Dali::Toolkit::Button *result = 0 ;
64265
64266   arg1 = (Dali::Toolkit::Button *)jarg1;
64267   arg2 = (Dali::Toolkit::Button *)jarg2;
64268   if (!arg2) {
64269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
64270     return 0;
64271   }
64272   {
64273     try {
64274       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
64275     } catch (std::out_of_range& e) {
64276       {
64277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64278       };
64279     } catch (std::exception& e) {
64280       {
64281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64282       };
64283     } catch (...) {
64284       {
64285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64286       };
64287     }
64288   }
64289   jresult = (void *)result;
64290   return jresult;
64291 }
64292
64293
64294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
64295   void * jresult ;
64296   Dali::BaseHandle arg1 ;
64297   Dali::BaseHandle *argp1 ;
64298   Dali::Toolkit::Button result;
64299
64300   argp1 = (Dali::BaseHandle *)jarg1;
64301   if (!argp1) {
64302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64303     return 0;
64304   }
64305   arg1 = *argp1;
64306   {
64307     try {
64308       result = Dali::Toolkit::Button::DownCast(arg1);
64309     } catch (std::out_of_range& e) {
64310       {
64311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64312       };
64313     } catch (std::exception& e) {
64314       {
64315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64316       };
64317     } catch (...) {
64318       {
64319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64320       };
64321     }
64322   }
64323   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
64324   return jresult;
64325 }
64326
64327
64328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
64329   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64330
64331   arg1 = (Dali::Toolkit::Button *)jarg1;
64332   {
64333     try {
64334       delete arg1;
64335     } catch (std::out_of_range& e) {
64336       {
64337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64338       };
64339     } catch (std::exception& e) {
64340       {
64341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64342       };
64343     } catch (...) {
64344       {
64345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64346       };
64347     }
64348   }
64349 }
64350
64351
64352 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
64353   unsigned int jresult ;
64354   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64355   bool result;
64356
64357   arg1 = (Dali::Toolkit::Button *)jarg1;
64358   {
64359     try {
64360       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
64361     } catch (std::out_of_range& e) {
64362       {
64363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64364       };
64365     } catch (std::exception& e) {
64366       {
64367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64368       };
64369     } catch (...) {
64370       {
64371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64372       };
64373     }
64374   }
64375   jresult = result;
64376   return jresult;
64377 }
64378
64379
64380 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
64381   unsigned int jresult ;
64382   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64383   bool result;
64384
64385   arg1 = (Dali::Toolkit::Button *)jarg1;
64386   {
64387     try {
64388       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
64389     } catch (std::out_of_range& e) {
64390       {
64391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64392       };
64393     } catch (std::exception& e) {
64394       {
64395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64396       };
64397     } catch (...) {
64398       {
64399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64400       };
64401     }
64402   }
64403   jresult = result;
64404   return jresult;
64405 }
64406
64407
64408 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
64409   float jresult ;
64410   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64411   float result;
64412
64413   arg1 = (Dali::Toolkit::Button *)jarg1;
64414   {
64415     try {
64416       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
64417     } catch (std::out_of_range& e) {
64418       {
64419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64420       };
64421     } catch (std::exception& e) {
64422       {
64423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64424       };
64425     } catch (...) {
64426       {
64427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64428       };
64429     }
64430   }
64431   jresult = result;
64432   return jresult;
64433 }
64434
64435
64436 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
64437   float jresult ;
64438   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64439   float result;
64440
64441   arg1 = (Dali::Toolkit::Button *)jarg1;
64442   {
64443     try {
64444       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
64445     } catch (std::out_of_range& e) {
64446       {
64447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64448       };
64449     } catch (std::exception& e) {
64450       {
64451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64452       };
64453     } catch (...) {
64454       {
64455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64456       };
64457     }
64458   }
64459   jresult = result;
64460   return jresult;
64461 }
64462
64463
64464 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
64465   unsigned int jresult ;
64466   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64467   bool result;
64468
64469   arg1 = (Dali::Toolkit::Button *)jarg1;
64470   {
64471     try {
64472       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
64473     } catch (std::out_of_range& e) {
64474       {
64475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64476       };
64477     } catch (std::exception& e) {
64478       {
64479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64480       };
64481     } catch (...) {
64482       {
64483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64484       };
64485     }
64486   }
64487   jresult = result;
64488   return jresult;
64489 }
64490
64491
64492 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
64493   unsigned int jresult ;
64494   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64495   bool result;
64496
64497   arg1 = (Dali::Toolkit::Button *)jarg1;
64498   {
64499     try {
64500       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
64501     } catch (std::out_of_range& e) {
64502       {
64503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64504       };
64505     } catch (std::exception& e) {
64506       {
64507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64508       };
64509     } catch (...) {
64510       {
64511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64512       };
64513     }
64514   }
64515   jresult = result;
64516   return jresult;
64517 }
64518
64519
64520 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
64521   float jresult ;
64522   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64523   float result;
64524
64525   arg1 = (Dali::Toolkit::Button *)jarg1;
64526   {
64527     try {
64528       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
64529     } catch (std::out_of_range& e) {
64530       {
64531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64532       };
64533     } catch (std::exception& e) {
64534       {
64535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64536       };
64537     } catch (...) {
64538       {
64539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64540       };
64541     }
64542   }
64543   jresult = result;
64544   return jresult;
64545 }
64546
64547
64548 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
64549   char * jresult ;
64550   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64551   std::string result;
64552
64553   arg1 = (Dali::Toolkit::Button *)jarg1;
64554   {
64555     try {
64556       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
64557     } catch (std::out_of_range& e) {
64558       {
64559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64560       };
64561     } catch (std::exception& e) {
64562       {
64563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64564       };
64565     } catch (...) {
64566       {
64567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64568       };
64569     }
64570   }
64571   jresult = SWIG_csharp_string_callback((&result)->c_str());
64572   return jresult;
64573 }
64574
64575
64576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
64577   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64578   Dali::Actor arg2 ;
64579   Dali::Actor *argp2 ;
64580
64581   arg1 = (Dali::Toolkit::Button *)jarg1;
64582   argp2 = (Dali::Actor *)jarg2;
64583   if (!argp2) {
64584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
64585     return ;
64586   }
64587   arg2 = *argp2;
64588   {
64589     try {
64590       (arg1)->SetLabel(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 void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
64609   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64610   Dali::Image arg2 ;
64611   Dali::Image *argp2 ;
64612
64613   arg1 = (Dali::Toolkit::Button *)jarg1;
64614   argp2 = (Dali::Image *)jarg2;
64615   if (!argp2) {
64616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
64617     return ;
64618   }
64619   arg2 = *argp2;
64620   {
64621     try {
64622       (arg1)->SetButtonImage(arg2);
64623     } catch (std::out_of_range& e) {
64624       {
64625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64626       };
64627     } catch (std::exception& e) {
64628       {
64629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64630       };
64631     } catch (...) {
64632       {
64633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64634       };
64635     }
64636   }
64637 }
64638
64639
64640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
64641   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64642   Dali::Image arg2 ;
64643   Dali::Image *argp2 ;
64644
64645   arg1 = (Dali::Toolkit::Button *)jarg1;
64646   argp2 = (Dali::Image *)jarg2;
64647   if (!argp2) {
64648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
64649     return ;
64650   }
64651   arg2 = *argp2;
64652   {
64653     try {
64654       (arg1)->SetSelectedImage(arg2);
64655     } catch (std::out_of_range& e) {
64656       {
64657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64658       };
64659     } catch (std::exception& e) {
64660       {
64661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64662       };
64663     } catch (...) {
64664       {
64665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64666       };
64667     }
64668   }
64669 }
64670
64671
64672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
64673   void * jresult ;
64674   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64675   Dali::Actor result;
64676
64677   arg1 = (Dali::Toolkit::Button *)jarg1;
64678   {
64679     try {
64680       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
64681     } catch (std::out_of_range& e) {
64682       {
64683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64684       };
64685     } catch (std::exception& e) {
64686       {
64687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64688       };
64689     } catch (...) {
64690       {
64691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64692       };
64693     }
64694   }
64695   jresult = new Dali::Actor((const Dali::Actor &)result);
64696   return jresult;
64697 }
64698
64699
64700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
64701   void * jresult ;
64702   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64703   Dali::Actor result;
64704
64705   arg1 = (Dali::Toolkit::Button *)jarg1;
64706   {
64707     try {
64708       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
64709     } catch (std::out_of_range& e) {
64710       {
64711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64712       };
64713     } catch (std::exception& e) {
64714       {
64715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64716       };
64717     } catch (...) {
64718       {
64719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64720       };
64721     }
64722   }
64723   jresult = new Dali::Actor((const Dali::Actor &)result);
64724   return jresult;
64725 }
64726
64727
64728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
64729   void * jresult ;
64730   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64731   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64732
64733   arg1 = (Dali::Toolkit::Button *)jarg1;
64734   {
64735     try {
64736       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
64737     } catch (std::out_of_range& e) {
64738       {
64739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64740       };
64741     } catch (std::exception& e) {
64742       {
64743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64744       };
64745     } catch (...) {
64746       {
64747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64748       };
64749     }
64750   }
64751   jresult = (void *)result;
64752   return jresult;
64753 }
64754
64755
64756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
64757   void * jresult ;
64758   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64759   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64760
64761   arg1 = (Dali::Toolkit::Button *)jarg1;
64762   {
64763     try {
64764       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
64765     } catch (std::out_of_range& e) {
64766       {
64767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64768       };
64769     } catch (std::exception& e) {
64770       {
64771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64772       };
64773     } catch (...) {
64774       {
64775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64776       };
64777     }
64778   }
64779   jresult = (void *)result;
64780   return jresult;
64781 }
64782
64783
64784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
64785   void * jresult ;
64786   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64787   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64788
64789   arg1 = (Dali::Toolkit::Button *)jarg1;
64790   {
64791     try {
64792       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
64793     } catch (std::out_of_range& e) {
64794       {
64795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64796       };
64797     } catch (std::exception& e) {
64798       {
64799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64800       };
64801     } catch (...) {
64802       {
64803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64804       };
64805     }
64806   }
64807   jresult = (void *)result;
64808   return jresult;
64809 }
64810
64811
64812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
64813   void * jresult ;
64814   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64815   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64816
64817   arg1 = (Dali::Toolkit::Button *)jarg1;
64818   {
64819     try {
64820       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
64821     } catch (std::out_of_range& e) {
64822       {
64823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64824       };
64825     } catch (std::exception& e) {
64826       {
64827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64828       };
64829     } catch (...) {
64830       {
64831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64832       };
64833     }
64834   }
64835   jresult = (void *)result;
64836   return jresult;
64837 }
64838
64839
64840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
64841   void * jresult ;
64842   Dali::Toolkit::CheckBoxButton *result = 0 ;
64843
64844   {
64845     try {
64846       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
64847     } catch (std::out_of_range& e) {
64848       {
64849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64850       };
64851     } catch (std::exception& e) {
64852       {
64853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64854       };
64855     } catch (...) {
64856       {
64857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64858       };
64859     }
64860   }
64861   jresult = (void *)result;
64862   return jresult;
64863 }
64864
64865
64866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
64867   void * jresult ;
64868   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
64869   Dali::Toolkit::CheckBoxButton *result = 0 ;
64870
64871   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
64872   if (!arg1) {
64873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
64874     return 0;
64875   }
64876   {
64877     try {
64878       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
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 = (void *)result;
64894   return jresult;
64895 }
64896
64897
64898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
64899   void * jresult ;
64900   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
64901   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
64902   Dali::Toolkit::CheckBoxButton *result = 0 ;
64903
64904   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
64905   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
64906   if (!arg2) {
64907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
64908     return 0;
64909   }
64910   {
64911     try {
64912       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
64913     } catch (std::out_of_range& e) {
64914       {
64915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64916       };
64917     } catch (std::exception& e) {
64918       {
64919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64920       };
64921     } catch (...) {
64922       {
64923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64924       };
64925     }
64926   }
64927   jresult = (void *)result;
64928   return jresult;
64929 }
64930
64931
64932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
64933   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
64934
64935   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
64936   {
64937     try {
64938       delete arg1;
64939     } catch (std::out_of_range& e) {
64940       {
64941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64942       };
64943     } catch (std::exception& e) {
64944       {
64945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64946       };
64947     } catch (...) {
64948       {
64949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64950       };
64951     }
64952   }
64953 }
64954
64955
64956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
64957   void * jresult ;
64958   Dali::Toolkit::CheckBoxButton result;
64959
64960   {
64961     try {
64962       result = Dali::Toolkit::CheckBoxButton::New();
64963     } catch (std::out_of_range& e) {
64964       {
64965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64966       };
64967     } catch (std::exception& e) {
64968       {
64969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64970       };
64971     } catch (...) {
64972       {
64973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64974       };
64975     }
64976   }
64977   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
64978   return jresult;
64979 }
64980
64981
64982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
64983   void * jresult ;
64984   Dali::BaseHandle arg1 ;
64985   Dali::BaseHandle *argp1 ;
64986   Dali::Toolkit::CheckBoxButton result;
64987
64988   argp1 = (Dali::BaseHandle *)jarg1;
64989   if (!argp1) {
64990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64991     return 0;
64992   }
64993   arg1 = *argp1;
64994   {
64995     try {
64996       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
64997     } catch (std::out_of_range& e) {
64998       {
64999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65000       };
65001     } catch (std::exception& e) {
65002       {
65003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65004       };
65005     } catch (...) {
65006       {
65007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65008       };
65009     }
65010   }
65011   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65012   return jresult;
65013 }
65014
65015
65016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
65017   int jresult ;
65018   int result;
65019
65020   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
65021   jresult = (int)result;
65022   return jresult;
65023 }
65024
65025
65026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
65027   int jresult ;
65028   int result;
65029
65030   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
65031   jresult = (int)result;
65032   return jresult;
65033 }
65034
65035
65036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
65037   int jresult ;
65038   int result;
65039
65040   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
65041   jresult = (int)result;
65042   return jresult;
65043 }
65044
65045
65046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
65047   int jresult ;
65048   int result;
65049
65050   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
65051   jresult = (int)result;
65052   return jresult;
65053 }
65054
65055
65056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
65057   int jresult ;
65058   int result;
65059
65060   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
65061   jresult = (int)result;
65062   return jresult;
65063 }
65064
65065
65066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
65067   void * jresult ;
65068   Dali::Toolkit::PushButton::Property *result = 0 ;
65069
65070   {
65071     try {
65072       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
65073     } catch (std::out_of_range& e) {
65074       {
65075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65076       };
65077     } catch (std::exception& e) {
65078       {
65079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65080       };
65081     } catch (...) {
65082       {
65083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65084       };
65085     }
65086   }
65087   jresult = (void *)result;
65088   return jresult;
65089 }
65090
65091
65092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
65093   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
65094
65095   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
65096   {
65097     try {
65098       delete arg1;
65099     } catch (std::out_of_range& e) {
65100       {
65101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65102       };
65103     } catch (std::exception& e) {
65104       {
65105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65106       };
65107     } catch (...) {
65108       {
65109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65110       };
65111     }
65112   }
65113 }
65114
65115
65116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
65117   void * jresult ;
65118   Dali::Toolkit::PushButton *result = 0 ;
65119
65120   {
65121     try {
65122       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
65123     } catch (std::out_of_range& e) {
65124       {
65125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65126       };
65127     } catch (std::exception& e) {
65128       {
65129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65130       };
65131     } catch (...) {
65132       {
65133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65134       };
65135     }
65136   }
65137   jresult = (void *)result;
65138   return jresult;
65139 }
65140
65141
65142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
65143   void * jresult ;
65144   Dali::Toolkit::PushButton *arg1 = 0 ;
65145   Dali::Toolkit::PushButton *result = 0 ;
65146
65147   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65148   if (!arg1) {
65149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65150     return 0;
65151   }
65152   {
65153     try {
65154       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
65155     } catch (std::out_of_range& e) {
65156       {
65157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65158       };
65159     } catch (std::exception& e) {
65160       {
65161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65162       };
65163     } catch (...) {
65164       {
65165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65166       };
65167     }
65168   }
65169   jresult = (void *)result;
65170   return jresult;
65171 }
65172
65173
65174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
65175   void * jresult ;
65176   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65177   Dali::Toolkit::PushButton *arg2 = 0 ;
65178   Dali::Toolkit::PushButton *result = 0 ;
65179
65180   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65181   arg2 = (Dali::Toolkit::PushButton *)jarg2;
65182   if (!arg2) {
65183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65184     return 0;
65185   }
65186   {
65187     try {
65188       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
65189     } catch (std::out_of_range& e) {
65190       {
65191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65192       };
65193     } catch (std::exception& e) {
65194       {
65195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65196       };
65197     } catch (...) {
65198       {
65199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65200       };
65201     }
65202   }
65203   jresult = (void *)result;
65204   return jresult;
65205 }
65206
65207
65208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
65209   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65210
65211   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65212   {
65213     try {
65214       delete arg1;
65215     } catch (std::out_of_range& e) {
65216       {
65217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65218       };
65219     } catch (std::exception& e) {
65220       {
65221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65222       };
65223     } catch (...) {
65224       {
65225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65226       };
65227     }
65228   }
65229 }
65230
65231
65232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
65233   void * jresult ;
65234   Dali::Toolkit::PushButton result;
65235
65236   {
65237     try {
65238       result = Dali::Toolkit::PushButton::New();
65239     } catch (std::out_of_range& e) {
65240       {
65241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65242       };
65243     } catch (std::exception& e) {
65244       {
65245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65246       };
65247     } catch (...) {
65248       {
65249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65250       };
65251     }
65252   }
65253   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65254   return jresult;
65255 }
65256
65257
65258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
65259   void * jresult ;
65260   Dali::BaseHandle arg1 ;
65261   Dali::BaseHandle *argp1 ;
65262   Dali::Toolkit::PushButton result;
65263
65264   argp1 = (Dali::BaseHandle *)jarg1;
65265   if (!argp1) {
65266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65267     return 0;
65268   }
65269   arg1 = *argp1;
65270   {
65271     try {
65272       result = Dali::Toolkit::PushButton::DownCast(arg1);
65273     } catch (std::out_of_range& e) {
65274       {
65275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65276       };
65277     } catch (std::exception& e) {
65278       {
65279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65280       };
65281     } catch (...) {
65282       {
65283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65284       };
65285     }
65286   }
65287   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65288   return jresult;
65289 }
65290
65291
65292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
65293   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65294   Dali::Image arg2 ;
65295   Dali::Image *argp2 ;
65296
65297   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65298   argp2 = (Dali::Image *)jarg2;
65299   if (!argp2) {
65300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65301     return ;
65302   }
65303   arg2 = *argp2;
65304   {
65305     try {
65306       (arg1)->SetButtonImage(arg2);
65307     } catch (std::out_of_range& e) {
65308       {
65309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65310       };
65311     } catch (std::exception& e) {
65312       {
65313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65314       };
65315     } catch (...) {
65316       {
65317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65318       };
65319     }
65320   }
65321 }
65322
65323
65324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
65325   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65326   Dali::Actor arg2 ;
65327   Dali::Actor *argp2 ;
65328
65329   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65330   argp2 = (Dali::Actor *)jarg2;
65331   if (!argp2) {
65332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65333     return ;
65334   }
65335   arg2 = *argp2;
65336   {
65337     try {
65338       (arg1)->SetButtonImage(arg2);
65339     } catch (std::out_of_range& e) {
65340       {
65341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65342       };
65343     } catch (std::exception& e) {
65344       {
65345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65346       };
65347     } catch (...) {
65348       {
65349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65350       };
65351     }
65352   }
65353 }
65354
65355
65356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
65357   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65358   Dali::Actor arg2 ;
65359   Dali::Actor *argp2 ;
65360
65361   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65362   argp2 = (Dali::Actor *)jarg2;
65363   if (!argp2) {
65364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65365     return ;
65366   }
65367   arg2 = *argp2;
65368   {
65369     try {
65370       (arg1)->SetBackgroundImage(arg2);
65371     } catch (std::out_of_range& e) {
65372       {
65373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65374       };
65375     } catch (std::exception& e) {
65376       {
65377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65378       };
65379     } catch (...) {
65380       {
65381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65382       };
65383     }
65384   }
65385 }
65386
65387
65388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
65389   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65390   Dali::Image arg2 ;
65391   Dali::Image *argp2 ;
65392
65393   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65394   argp2 = (Dali::Image *)jarg2;
65395   if (!argp2) {
65396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65397     return ;
65398   }
65399   arg2 = *argp2;
65400   {
65401     try {
65402       (arg1)->SetSelectedImage(arg2);
65403     } catch (std::out_of_range& e) {
65404       {
65405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65406       };
65407     } catch (std::exception& e) {
65408       {
65409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65410       };
65411     } catch (...) {
65412       {
65413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65414       };
65415     }
65416   }
65417 }
65418
65419
65420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
65421   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65422   Dali::Actor arg2 ;
65423   Dali::Actor *argp2 ;
65424
65425   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65426   argp2 = (Dali::Actor *)jarg2;
65427   if (!argp2) {
65428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65429     return ;
65430   }
65431   arg2 = *argp2;
65432   {
65433     try {
65434       (arg1)->SetSelectedImage(arg2);
65435     } catch (std::out_of_range& e) {
65436       {
65437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65438       };
65439     } catch (std::exception& e) {
65440       {
65441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65442       };
65443     } catch (...) {
65444       {
65445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65446       };
65447     }
65448   }
65449 }
65450
65451
65452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
65453   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65454   Dali::Actor arg2 ;
65455   Dali::Actor *argp2 ;
65456
65457   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65458   argp2 = (Dali::Actor *)jarg2;
65459   if (!argp2) {
65460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65461     return ;
65462   }
65463   arg2 = *argp2;
65464   {
65465     try {
65466       (arg1)->SetSelectedBackgroundImage(arg2);
65467     } catch (std::out_of_range& e) {
65468       {
65469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65470       };
65471     } catch (std::exception& e) {
65472       {
65473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65474       };
65475     } catch (...) {
65476       {
65477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65478       };
65479     }
65480   }
65481 }
65482
65483
65484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
65485   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65486   Dali::Actor arg2 ;
65487   Dali::Actor *argp2 ;
65488
65489   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65490   argp2 = (Dali::Actor *)jarg2;
65491   if (!argp2) {
65492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65493     return ;
65494   }
65495   arg2 = *argp2;
65496   {
65497     try {
65498       (arg1)->SetDisabledBackgroundImage(arg2);
65499     } catch (std::out_of_range& e) {
65500       {
65501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65502       };
65503     } catch (std::exception& e) {
65504       {
65505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65506       };
65507     } catch (...) {
65508       {
65509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65510       };
65511     }
65512   }
65513 }
65514
65515
65516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
65517   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65518   Dali::Actor arg2 ;
65519   Dali::Actor *argp2 ;
65520
65521   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65522   argp2 = (Dali::Actor *)jarg2;
65523   if (!argp2) {
65524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65525     return ;
65526   }
65527   arg2 = *argp2;
65528   {
65529     try {
65530       (arg1)->SetDisabledImage(arg2);
65531     } catch (std::out_of_range& e) {
65532       {
65533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65534       };
65535     } catch (std::exception& e) {
65536       {
65537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65538       };
65539     } catch (...) {
65540       {
65541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65542       };
65543     }
65544   }
65545 }
65546
65547
65548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
65549   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65550   Dali::Actor arg2 ;
65551   Dali::Actor *argp2 ;
65552
65553   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65554   argp2 = (Dali::Actor *)jarg2;
65555   if (!argp2) {
65556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65557     return ;
65558   }
65559   arg2 = *argp2;
65560   {
65561     try {
65562       (arg1)->SetDisabledSelectedImage(arg2);
65563     } catch (std::out_of_range& e) {
65564       {
65565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65566       };
65567     } catch (std::exception& e) {
65568       {
65569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65570       };
65571     } catch (...) {
65572       {
65573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65574       };
65575     }
65576   }
65577 }
65578
65579
65580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
65581   void * jresult ;
65582   Dali::Toolkit::RadioButton *result = 0 ;
65583
65584   {
65585     try {
65586       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
65587     } catch (std::out_of_range& e) {
65588       {
65589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65590       };
65591     } catch (std::exception& e) {
65592       {
65593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65594       };
65595     } catch (...) {
65596       {
65597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65598       };
65599     }
65600   }
65601   jresult = (void *)result;
65602   return jresult;
65603 }
65604
65605
65606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
65607   void * jresult ;
65608   Dali::Toolkit::RadioButton *arg1 = 0 ;
65609   Dali::Toolkit::RadioButton *result = 0 ;
65610
65611   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65612   if (!arg1) {
65613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65614     return 0;
65615   }
65616   {
65617     try {
65618       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
65619     } catch (std::out_of_range& e) {
65620       {
65621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65622       };
65623     } catch (std::exception& e) {
65624       {
65625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65626       };
65627     } catch (...) {
65628       {
65629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65630       };
65631     }
65632   }
65633   jresult = (void *)result;
65634   return jresult;
65635 }
65636
65637
65638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
65639   void * jresult ;
65640   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65641   Dali::Toolkit::RadioButton *arg2 = 0 ;
65642   Dali::Toolkit::RadioButton *result = 0 ;
65643
65644   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65645   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
65646   if (!arg2) {
65647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65648     return 0;
65649   }
65650   {
65651     try {
65652       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
65653     } catch (std::out_of_range& e) {
65654       {
65655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65656       };
65657     } catch (std::exception& e) {
65658       {
65659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65660       };
65661     } catch (...) {
65662       {
65663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65664       };
65665     }
65666   }
65667   jresult = (void *)result;
65668   return jresult;
65669 }
65670
65671
65672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
65673   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65674
65675   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65676   {
65677     try {
65678       delete arg1;
65679     } catch (std::out_of_range& e) {
65680       {
65681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65682       };
65683     } catch (std::exception& e) {
65684       {
65685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65686       };
65687     } catch (...) {
65688       {
65689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65690       };
65691     }
65692   }
65693 }
65694
65695
65696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
65697   void * jresult ;
65698   Dali::Toolkit::RadioButton result;
65699
65700   {
65701     try {
65702       result = Dali::Toolkit::RadioButton::New();
65703     } catch (std::out_of_range& e) {
65704       {
65705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65706       };
65707     } catch (std::exception& e) {
65708       {
65709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65710       };
65711     } catch (...) {
65712       {
65713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65714       };
65715     }
65716   }
65717   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65718   return jresult;
65719 }
65720
65721
65722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
65723   void * jresult ;
65724   std::string *arg1 = 0 ;
65725   Dali::Toolkit::RadioButton result;
65726
65727   if (!jarg1) {
65728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
65729     return 0;
65730   }
65731   std::string arg1_str(jarg1);
65732   arg1 = &arg1_str;
65733   {
65734     try {
65735       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
65736     } catch (std::out_of_range& e) {
65737       {
65738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65739       };
65740     } catch (std::exception& e) {
65741       {
65742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65743       };
65744     } catch (...) {
65745       {
65746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65747       };
65748     }
65749   }
65750   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65751
65752   //argout typemap for const std::string&
65753
65754   return jresult;
65755 }
65756
65757
65758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
65759   void * jresult ;
65760   Dali::BaseHandle arg1 ;
65761   Dali::BaseHandle *argp1 ;
65762   Dali::Toolkit::RadioButton result;
65763
65764   argp1 = (Dali::BaseHandle *)jarg1;
65765   if (!argp1) {
65766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65767     return 0;
65768   }
65769   arg1 = *argp1;
65770   {
65771     try {
65772       result = Dali::Toolkit::RadioButton::DownCast(arg1);
65773     } catch (std::out_of_range& e) {
65774       {
65775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65776       };
65777     } catch (std::exception& e) {
65778       {
65779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65780       };
65781     } catch (...) {
65782       {
65783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65784       };
65785     }
65786   }
65787   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65788   return jresult;
65789 }
65790
65791
65792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
65793   int jresult ;
65794   int result;
65795
65796   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
65797   jresult = (int)result;
65798   return jresult;
65799 }
65800
65801
65802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
65803   int jresult ;
65804   int result;
65805
65806   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
65807   jresult = (int)result;
65808   return jresult;
65809 }
65810
65811
65812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
65813   int jresult ;
65814   int result;
65815
65816   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
65817   jresult = (int)result;
65818   return jresult;
65819 }
65820
65821
65822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
65823   int jresult ;
65824   int result;
65825
65826   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
65827   jresult = (int)result;
65828   return jresult;
65829 }
65830
65831
65832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
65833   int jresult ;
65834   int result;
65835
65836   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
65837   jresult = (int)result;
65838   return jresult;
65839 }
65840
65841
65842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
65843   int jresult ;
65844   int result;
65845
65846   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
65847   jresult = (int)result;
65848   return jresult;
65849 }
65850
65851
65852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
65853   void * jresult ;
65854   Dali::Toolkit::FlexContainer::Property *result = 0 ;
65855
65856   {
65857     try {
65858       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
65859     } catch (std::out_of_range& e) {
65860       {
65861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65862       };
65863     } catch (std::exception& e) {
65864       {
65865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65866       };
65867     } catch (...) {
65868       {
65869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65870       };
65871     }
65872   }
65873   jresult = (void *)result;
65874   return jresult;
65875 }
65876
65877
65878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
65879   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
65880
65881   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
65882   {
65883     try {
65884       delete arg1;
65885     } catch (std::out_of_range& e) {
65886       {
65887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65888       };
65889     } catch (std::exception& e) {
65890       {
65891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65892       };
65893     } catch (...) {
65894       {
65895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65896       };
65897     }
65898   }
65899 }
65900
65901
65902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
65903   int jresult ;
65904   int result;
65905
65906   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
65907   jresult = (int)result;
65908   return jresult;
65909 }
65910
65911
65912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
65913   int jresult ;
65914   int result;
65915
65916   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
65917   jresult = (int)result;
65918   return jresult;
65919 }
65920
65921
65922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
65923   int jresult ;
65924   int result;
65925
65926   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
65927   jresult = (int)result;
65928   return jresult;
65929 }
65930
65931
65932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
65933   void * jresult ;
65934   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
65935
65936   {
65937     try {
65938       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
65939     } catch (std::out_of_range& e) {
65940       {
65941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65942       };
65943     } catch (std::exception& e) {
65944       {
65945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65946       };
65947     } catch (...) {
65948       {
65949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65950       };
65951     }
65952   }
65953   jresult = (void *)result;
65954   return jresult;
65955 }
65956
65957
65958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
65959   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
65960
65961   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
65962   {
65963     try {
65964       delete arg1;
65965     } catch (std::out_of_range& e) {
65966       {
65967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65968       };
65969     } catch (std::exception& e) {
65970       {
65971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65972       };
65973     } catch (...) {
65974       {
65975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65976       };
65977     }
65978   }
65979 }
65980
65981
65982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
65983   void * jresult ;
65984   Dali::Toolkit::FlexContainer *result = 0 ;
65985
65986   {
65987     try {
65988       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
65989     } catch (std::out_of_range& e) {
65990       {
65991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65992       };
65993     } catch (std::exception& e) {
65994       {
65995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65996       };
65997     } catch (...) {
65998       {
65999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66000       };
66001     }
66002   }
66003   jresult = (void *)result;
66004   return jresult;
66005 }
66006
66007
66008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
66009   void * jresult ;
66010   Dali::Toolkit::FlexContainer *arg1 = 0 ;
66011   Dali::Toolkit::FlexContainer *result = 0 ;
66012
66013   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66014   if (!arg1) {
66015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66016     return 0;
66017   }
66018   {
66019     try {
66020       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
66021     } catch (std::out_of_range& e) {
66022       {
66023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66024       };
66025     } catch (std::exception& e) {
66026       {
66027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66028       };
66029     } catch (...) {
66030       {
66031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66032       };
66033     }
66034   }
66035   jresult = (void *)result;
66036   return jresult;
66037 }
66038
66039
66040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
66041   void * jresult ;
66042   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66043   Dali::Toolkit::FlexContainer *arg2 = 0 ;
66044   Dali::Toolkit::FlexContainer *result = 0 ;
66045
66046   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66047   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
66048   if (!arg2) {
66049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66050     return 0;
66051   }
66052   {
66053     try {
66054       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
66055     } catch (std::out_of_range& e) {
66056       {
66057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66058       };
66059     } catch (std::exception& e) {
66060       {
66061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66062       };
66063     } catch (...) {
66064       {
66065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66066       };
66067     }
66068   }
66069   jresult = (void *)result;
66070   return jresult;
66071 }
66072
66073
66074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
66075   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66076
66077   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66078   {
66079     try {
66080       delete arg1;
66081     } catch (std::out_of_range& e) {
66082       {
66083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66084       };
66085     } catch (std::exception& e) {
66086       {
66087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66088       };
66089     } catch (...) {
66090       {
66091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66092       };
66093     }
66094   }
66095 }
66096
66097
66098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
66099   void * jresult ;
66100   Dali::Toolkit::FlexContainer result;
66101
66102   {
66103     try {
66104       result = Dali::Toolkit::FlexContainer::New();
66105     } catch (std::out_of_range& e) {
66106       {
66107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66108       };
66109     } catch (std::exception& e) {
66110       {
66111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66112       };
66113     } catch (...) {
66114       {
66115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66116       };
66117     }
66118   }
66119   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66120   return jresult;
66121 }
66122
66123
66124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
66125   void * jresult ;
66126   Dali::BaseHandle arg1 ;
66127   Dali::BaseHandle *argp1 ;
66128   Dali::Toolkit::FlexContainer result;
66129
66130   argp1 = (Dali::BaseHandle *)jarg1;
66131   if (!argp1) {
66132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66133     return 0;
66134   }
66135   arg1 = *argp1;
66136   {
66137     try {
66138       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
66139     } catch (std::out_of_range& e) {
66140       {
66141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66142       };
66143     } catch (std::exception& e) {
66144       {
66145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66146       };
66147     } catch (...) {
66148       {
66149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66150       };
66151     }
66152   }
66153   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66154   return jresult;
66155 }
66156
66157
66158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
66159   int jresult ;
66160   int result;
66161
66162   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
66163   jresult = (int)result;
66164   return jresult;
66165 }
66166
66167
66168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
66169   int jresult ;
66170   int result;
66171
66172   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
66173   jresult = (int)result;
66174   return jresult;
66175 }
66176
66177
66178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
66179   int jresult ;
66180   int result;
66181
66182   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
66183   jresult = (int)result;
66184   return jresult;
66185 }
66186
66187
66188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
66189   int jresult ;
66190   int result;
66191
66192   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
66193   jresult = (int)result;
66194   return jresult;
66195 }
66196
66197
66198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
66199   void * jresult ;
66200   Dali::Toolkit::ImageView::Property *result = 0 ;
66201
66202   {
66203     try {
66204       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
66205     } catch (std::out_of_range& e) {
66206       {
66207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66208       };
66209     } catch (std::exception& e) {
66210       {
66211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66212       };
66213     } catch (...) {
66214       {
66215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66216       };
66217     }
66218   }
66219   jresult = (void *)result;
66220   return jresult;
66221 }
66222
66223
66224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
66225   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
66226
66227   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
66228   {
66229     try {
66230       delete arg1;
66231     } catch (std::out_of_range& e) {
66232       {
66233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66234       };
66235     } catch (std::exception& e) {
66236       {
66237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66238       };
66239     } catch (...) {
66240       {
66241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66242       };
66243     }
66244   }
66245 }
66246
66247
66248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
66249   void * jresult ;
66250   Dali::Toolkit::ImageView *result = 0 ;
66251
66252   {
66253     try {
66254       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
66255     } catch (std::out_of_range& e) {
66256       {
66257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66258       };
66259     } catch (std::exception& e) {
66260       {
66261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66262       };
66263     } catch (...) {
66264       {
66265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66266       };
66267     }
66268   }
66269   jresult = (void *)result;
66270   return jresult;
66271 }
66272
66273
66274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
66275   void * jresult ;
66276   Dali::Toolkit::ImageView result;
66277
66278   {
66279     try {
66280       result = Dali::Toolkit::ImageView::New();
66281     } catch (std::out_of_range& e) {
66282       {
66283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66284       };
66285     } catch (std::exception& e) {
66286       {
66287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66288       };
66289     } catch (...) {
66290       {
66291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66292       };
66293     }
66294   }
66295   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66296   return jresult;
66297 }
66298
66299
66300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
66301   void * jresult ;
66302   Dali::Image arg1 ;
66303   Dali::Image *argp1 ;
66304   Dali::Toolkit::ImageView result;
66305
66306   argp1 = (Dali::Image *)jarg1;
66307   if (!argp1) {
66308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
66309     return 0;
66310   }
66311   arg1 = *argp1;
66312   {
66313     try {
66314       result = Dali::Toolkit::ImageView::New(arg1);
66315     } catch (std::out_of_range& e) {
66316       {
66317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66318       };
66319     } catch (std::exception& e) {
66320       {
66321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66322       };
66323     } catch (...) {
66324       {
66325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66326       };
66327     }
66328   }
66329   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66330   return jresult;
66331 }
66332
66333
66334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
66335   void * jresult ;
66336   std::string *arg1 = 0 ;
66337   Dali::Toolkit::ImageView result;
66338
66339   if (!jarg1) {
66340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66341     return 0;
66342   }
66343   std::string arg1_str(jarg1);
66344   arg1 = &arg1_str;
66345   {
66346     try {
66347       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
66348     } catch (std::out_of_range& e) {
66349       {
66350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66351       };
66352     } catch (std::exception& e) {
66353       {
66354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66355       };
66356     } catch (...) {
66357       {
66358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66359       };
66360     }
66361   }
66362   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66363
66364   //argout typemap for const std::string&
66365
66366   return jresult;
66367 }
66368
66369
66370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
66371   void * jresult ;
66372   std::string *arg1 = 0 ;
66373   Dali::ImageDimensions arg2 ;
66374   Dali::ImageDimensions *argp2 ;
66375   Dali::Toolkit::ImageView result;
66376
66377   if (!jarg1) {
66378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66379     return 0;
66380   }
66381   std::string arg1_str(jarg1);
66382   arg1 = &arg1_str;
66383   argp2 = (Dali::ImageDimensions *)jarg2;
66384   if (!argp2) {
66385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66386     return 0;
66387   }
66388   arg2 = *argp2;
66389   {
66390     try {
66391       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
66392     } catch (std::out_of_range& e) {
66393       {
66394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66395       };
66396     } catch (std::exception& e) {
66397       {
66398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66399       };
66400     } catch (...) {
66401       {
66402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66403       };
66404     }
66405   }
66406   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66407
66408   //argout typemap for const std::string&
66409
66410   return jresult;
66411 }
66412
66413
66414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
66415   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66416
66417   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66418   {
66419     try {
66420       delete arg1;
66421     } catch (std::out_of_range& e) {
66422       {
66423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66424       };
66425     } catch (std::exception& e) {
66426       {
66427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66428       };
66429     } catch (...) {
66430       {
66431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66432       };
66433     }
66434   }
66435 }
66436
66437
66438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
66439   void * jresult ;
66440   Dali::Toolkit::ImageView *arg1 = 0 ;
66441   Dali::Toolkit::ImageView *result = 0 ;
66442
66443   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66444   if (!arg1) {
66445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66446     return 0;
66447   }
66448   {
66449     try {
66450       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
66451     } catch (std::out_of_range& e) {
66452       {
66453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66454       };
66455     } catch (std::exception& e) {
66456       {
66457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66458       };
66459     } catch (...) {
66460       {
66461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66462       };
66463     }
66464   }
66465   jresult = (void *)result;
66466   return jresult;
66467 }
66468
66469
66470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
66471   void * jresult ;
66472   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66473   Dali::Toolkit::ImageView *arg2 = 0 ;
66474   Dali::Toolkit::ImageView *result = 0 ;
66475
66476   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66477   arg2 = (Dali::Toolkit::ImageView *)jarg2;
66478   if (!arg2) {
66479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66480     return 0;
66481   }
66482   {
66483     try {
66484       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
66485     } catch (std::out_of_range& e) {
66486       {
66487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66488       };
66489     } catch (std::exception& e) {
66490       {
66491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66492       };
66493     } catch (...) {
66494       {
66495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66496       };
66497     }
66498   }
66499   jresult = (void *)result;
66500   return jresult;
66501 }
66502
66503
66504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
66505   void * jresult ;
66506   Dali::BaseHandle arg1 ;
66507   Dali::BaseHandle *argp1 ;
66508   Dali::Toolkit::ImageView result;
66509
66510   argp1 = (Dali::BaseHandle *)jarg1;
66511   if (!argp1) {
66512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66513     return 0;
66514   }
66515   arg1 = *argp1;
66516   {
66517     try {
66518       result = Dali::Toolkit::ImageView::DownCast(arg1);
66519     } catch (std::out_of_range& e) {
66520       {
66521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66522       };
66523     } catch (std::exception& e) {
66524       {
66525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66526       };
66527     } catch (...) {
66528       {
66529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66530       };
66531     }
66532   }
66533   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66534   return jresult;
66535 }
66536
66537
66538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
66539   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66540   Dali::Image arg2 ;
66541   Dali::Image *argp2 ;
66542
66543   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66544   argp2 = (Dali::Image *)jarg2;
66545   if (!argp2) {
66546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
66547     return ;
66548   }
66549   arg2 = *argp2;
66550   {
66551     try {
66552       (arg1)->SetImage(arg2);
66553     } catch (std::out_of_range& e) {
66554       {
66555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66556       };
66557     } catch (std::exception& e) {
66558       {
66559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66560       };
66561     } catch (...) {
66562       {
66563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66564       };
66565     }
66566   }
66567 }
66568
66569
66570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
66571   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66572   std::string *arg2 = 0 ;
66573
66574   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66575   if (!jarg2) {
66576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66577     return ;
66578   }
66579   std::string arg2_str(jarg2);
66580   arg2 = &arg2_str;
66581   {
66582     try {
66583       (arg1)->SetImage((std::string const &)*arg2);
66584     } catch (std::out_of_range& e) {
66585       {
66586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66587       };
66588     } catch (std::exception& e) {
66589       {
66590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66591       };
66592     } catch (...) {
66593       {
66594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66595       };
66596     }
66597   }
66598
66599   //argout typemap for const std::string&
66600
66601 }
66602
66603
66604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
66605   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66606   std::string *arg2 = 0 ;
66607   Dali::ImageDimensions arg3 ;
66608   Dali::ImageDimensions *argp3 ;
66609
66610   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66611   if (!jarg2) {
66612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66613     return ;
66614   }
66615   std::string arg2_str(jarg2);
66616   arg2 = &arg2_str;
66617   argp3 = (Dali::ImageDimensions *)jarg3;
66618   if (!argp3) {
66619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66620     return ;
66621   }
66622   arg3 = *argp3;
66623   {
66624     try {
66625       (arg1)->SetImage((std::string const &)*arg2,arg3);
66626     } catch (std::out_of_range& e) {
66627       {
66628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66629       };
66630     } catch (std::exception& e) {
66631       {
66632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66633       };
66634     } catch (...) {
66635       {
66636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66637       };
66638     }
66639   }
66640
66641   //argout typemap for const std::string&
66642
66643 }
66644
66645
66646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
66647   void * jresult ;
66648   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66649   Dali::Image result;
66650
66651   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66652   {
66653     try {
66654       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
66655     } catch (std::out_of_range& e) {
66656       {
66657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66658       };
66659     } catch (std::exception& e) {
66660       {
66661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66662       };
66663     } catch (...) {
66664       {
66665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66666       };
66667     }
66668   }
66669   jresult = new Dali::Image((const Dali::Image &)result);
66670   return jresult;
66671 }
66672
66673
66674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
66675   int jresult ;
66676   int result;
66677
66678   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
66679   jresult = (int)result;
66680   return jresult;
66681 }
66682
66683
66684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
66685   int jresult ;
66686   int result;
66687
66688   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
66689   jresult = (int)result;
66690   return jresult;
66691 }
66692
66693
66694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
66695   int jresult ;
66696   int result;
66697
66698   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
66699   jresult = (int)result;
66700   return jresult;
66701 }
66702
66703
66704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
66705   int jresult ;
66706   int result;
66707
66708   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
66709   jresult = (int)result;
66710   return jresult;
66711 }
66712
66713
66714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
66715   int jresult ;
66716   int result;
66717
66718   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
66719   jresult = (int)result;
66720   return jresult;
66721 }
66722
66723
66724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
66725   int jresult ;
66726   int result;
66727
66728   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
66729   jresult = (int)result;
66730   return jresult;
66731 }
66732
66733
66734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
66735   int jresult ;
66736   int result;
66737
66738   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
66739   jresult = (int)result;
66740   return jresult;
66741 }
66742
66743
66744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
66745   int jresult ;
66746   int result;
66747
66748   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
66749   jresult = (int)result;
66750   return jresult;
66751 }
66752
66753
66754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
66755   void * jresult ;
66756   Dali::Toolkit::Model3dView::Property *result = 0 ;
66757
66758   {
66759     try {
66760       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
66761     } catch (std::out_of_range& e) {
66762       {
66763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66764       };
66765     } catch (std::exception& e) {
66766       {
66767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66768       };
66769     } catch (...) {
66770       {
66771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66772       };
66773     }
66774   }
66775   jresult = (void *)result;
66776   return jresult;
66777 }
66778
66779
66780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
66781   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
66782
66783   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
66784   {
66785     try {
66786       delete arg1;
66787     } catch (std::out_of_range& e) {
66788       {
66789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66790       };
66791     } catch (std::exception& e) {
66792       {
66793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66794       };
66795     } catch (...) {
66796       {
66797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66798       };
66799     }
66800   }
66801 }
66802
66803
66804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
66805   void * jresult ;
66806   Dali::Toolkit::Model3dView result;
66807
66808   {
66809     try {
66810       result = Dali::Toolkit::Model3dView::New();
66811     } catch (std::out_of_range& e) {
66812       {
66813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66814       };
66815     } catch (std::exception& e) {
66816       {
66817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66818       };
66819     } catch (...) {
66820       {
66821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66822       };
66823     }
66824   }
66825   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
66826   return jresult;
66827 }
66828
66829
66830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
66831   void * jresult ;
66832   std::string *arg1 = 0 ;
66833   std::string *arg2 = 0 ;
66834   std::string *arg3 = 0 ;
66835   Dali::Toolkit::Model3dView result;
66836
66837   if (!jarg1) {
66838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66839     return 0;
66840   }
66841   std::string arg1_str(jarg1);
66842   arg1 = &arg1_str;
66843   if (!jarg2) {
66844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66845     return 0;
66846   }
66847   std::string arg2_str(jarg2);
66848   arg2 = &arg2_str;
66849   if (!jarg3) {
66850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66851     return 0;
66852   }
66853   std::string arg3_str(jarg3);
66854   arg3 = &arg3_str;
66855   {
66856     try {
66857       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
66858     } catch (std::out_of_range& e) {
66859       {
66860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66861       };
66862     } catch (std::exception& e) {
66863       {
66864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66865       };
66866     } catch (...) {
66867       {
66868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66869       };
66870     }
66871   }
66872   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
66873
66874   //argout typemap for const std::string&
66875
66876
66877   //argout typemap for const std::string&
66878
66879
66880   //argout typemap for const std::string&
66881
66882   return jresult;
66883 }
66884
66885
66886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
66887   void * jresult ;
66888   Dali::Toolkit::Model3dView *result = 0 ;
66889
66890   {
66891     try {
66892       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
66893     } catch (std::out_of_range& e) {
66894       {
66895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66896       };
66897     } catch (std::exception& e) {
66898       {
66899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66900       };
66901     } catch (...) {
66902       {
66903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66904       };
66905     }
66906   }
66907   jresult = (void *)result;
66908   return jresult;
66909 }
66910
66911
66912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
66913   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
66914
66915   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
66916   {
66917     try {
66918       delete arg1;
66919     } catch (std::out_of_range& e) {
66920       {
66921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66922       };
66923     } catch (std::exception& e) {
66924       {
66925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66926       };
66927     } catch (...) {
66928       {
66929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66930       };
66931     }
66932   }
66933 }
66934
66935
66936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
66937   void * jresult ;
66938   Dali::Toolkit::Model3dView *arg1 = 0 ;
66939   Dali::Toolkit::Model3dView *result = 0 ;
66940
66941   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
66942   if (!arg1) {
66943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
66944     return 0;
66945   }
66946   {
66947     try {
66948       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
66949     } catch (std::out_of_range& e) {
66950       {
66951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66952       };
66953     } catch (std::exception& e) {
66954       {
66955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66956       };
66957     } catch (...) {
66958       {
66959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66960       };
66961     }
66962   }
66963   jresult = (void *)result;
66964   return jresult;
66965 }
66966
66967
66968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
66969   void * jresult ;
66970   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
66971   Dali::Toolkit::Model3dView *arg2 = 0 ;
66972   Dali::Toolkit::Model3dView *result = 0 ;
66973
66974   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
66975   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
66976   if (!arg2) {
66977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
66978     return 0;
66979   }
66980   {
66981     try {
66982       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
66983     } catch (std::out_of_range& e) {
66984       {
66985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66986       };
66987     } catch (std::exception& e) {
66988       {
66989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66990       };
66991     } catch (...) {
66992       {
66993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66994       };
66995     }
66996   }
66997   jresult = (void *)result;
66998   return jresult;
66999 }
67000
67001
67002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
67003   void * jresult ;
67004   Dali::BaseHandle arg1 ;
67005   Dali::BaseHandle *argp1 ;
67006   Dali::Toolkit::Model3dView result;
67007
67008   argp1 = (Dali::BaseHandle *)jarg1;
67009   if (!argp1) {
67010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67011     return 0;
67012   }
67013   arg1 = *argp1;
67014   {
67015     try {
67016       result = Dali::Toolkit::Model3dView::DownCast(arg1);
67017     } catch (std::out_of_range& e) {
67018       {
67019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67020       };
67021     } catch (std::exception& e) {
67022       {
67023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67024       };
67025     } catch (...) {
67026       {
67027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67028       };
67029     }
67030   }
67031   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67032   return jresult;
67033 }
67034
67035
67036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
67037   int jresult ;
67038   int result;
67039
67040   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
67041   jresult = (int)result;
67042   return jresult;
67043 }
67044
67045
67046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
67047   int jresult ;
67048   int result;
67049
67050   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
67051   jresult = (int)result;
67052   return jresult;
67053 }
67054
67055
67056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
67057   int jresult ;
67058   int result;
67059
67060   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
67061   jresult = (int)result;
67062   return jresult;
67063 }
67064
67065
67066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
67067   int jresult ;
67068   int result;
67069
67070   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
67071   jresult = (int)result;
67072   return jresult;
67073 }
67074
67075
67076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
67077   int jresult ;
67078   int result;
67079
67080   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
67081   jresult = (int)result;
67082   return jresult;
67083 }
67084
67085
67086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
67087   int jresult ;
67088   int result;
67089
67090   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
67091   jresult = (int)result;
67092   return jresult;
67093 }
67094
67095
67096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
67097   int jresult ;
67098   int result;
67099
67100   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
67101   jresult = (int)result;
67102   return jresult;
67103 }
67104
67105
67106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
67107   int jresult ;
67108   int result;
67109
67110   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
67111   jresult = (int)result;
67112   return jresult;
67113 }
67114
67115
67116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
67117   int jresult ;
67118   int result;
67119
67120   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
67121   jresult = (int)result;
67122   return jresult;
67123 }
67124
67125
67126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
67127   void * jresult ;
67128   Dali::Toolkit::ScrollBar::Property *result = 0 ;
67129
67130   {
67131     try {
67132       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
67133     } catch (std::out_of_range& e) {
67134       {
67135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67136       };
67137     } catch (std::exception& e) {
67138       {
67139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67140       };
67141     } catch (...) {
67142       {
67143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67144       };
67145     }
67146   }
67147   jresult = (void *)result;
67148   return jresult;
67149 }
67150
67151
67152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
67153   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
67154
67155   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
67156   {
67157     try {
67158       delete arg1;
67159     } catch (std::out_of_range& e) {
67160       {
67161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67162       };
67163     } catch (std::exception& e) {
67164       {
67165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67166       };
67167     } catch (...) {
67168       {
67169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67170       };
67171     }
67172   }
67173 }
67174
67175
67176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
67177   void * jresult ;
67178   Dali::Toolkit::ScrollBar *result = 0 ;
67179
67180   {
67181     try {
67182       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
67183     } catch (std::out_of_range& e) {
67184       {
67185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67186       };
67187     } catch (std::exception& e) {
67188       {
67189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67190       };
67191     } catch (...) {
67192       {
67193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67194       };
67195     }
67196   }
67197   jresult = (void *)result;
67198   return jresult;
67199 }
67200
67201
67202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
67203   void * jresult ;
67204   Dali::Toolkit::ScrollBar *arg1 = 0 ;
67205   Dali::Toolkit::ScrollBar *result = 0 ;
67206
67207   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67208   if (!arg1) {
67209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67210     return 0;
67211   }
67212   {
67213     try {
67214       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
67215     } catch (std::out_of_range& e) {
67216       {
67217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67218       };
67219     } catch (std::exception& e) {
67220       {
67221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67222       };
67223     } catch (...) {
67224       {
67225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67226       };
67227     }
67228   }
67229   jresult = (void *)result;
67230   return jresult;
67231 }
67232
67233
67234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
67235   void * jresult ;
67236   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67237   Dali::Toolkit::ScrollBar *arg2 = 0 ;
67238   Dali::Toolkit::ScrollBar *result = 0 ;
67239
67240   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67241   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
67242   if (!arg2) {
67243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67244     return 0;
67245   }
67246   {
67247     try {
67248       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
67249     } catch (std::out_of_range& e) {
67250       {
67251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67252       };
67253     } catch (std::exception& e) {
67254       {
67255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67256       };
67257     } catch (...) {
67258       {
67259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67260       };
67261     }
67262   }
67263   jresult = (void *)result;
67264   return jresult;
67265 }
67266
67267
67268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
67269   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67270
67271   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67272   {
67273     try {
67274       delete arg1;
67275     } catch (std::out_of_range& e) {
67276       {
67277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67278       };
67279     } catch (std::exception& e) {
67280       {
67281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67282       };
67283     } catch (...) {
67284       {
67285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67286       };
67287     }
67288   }
67289 }
67290
67291
67292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
67293   void * jresult ;
67294   Dali::Toolkit::ScrollBar::Direction arg1 ;
67295   Dali::Toolkit::ScrollBar result;
67296
67297   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
67298   {
67299     try {
67300       result = Dali::Toolkit::ScrollBar::New(arg1);
67301     } catch (std::out_of_range& e) {
67302       {
67303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67304       };
67305     } catch (std::exception& e) {
67306       {
67307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67308       };
67309     } catch (...) {
67310       {
67311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67312       };
67313     }
67314   }
67315   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67316   return jresult;
67317 }
67318
67319
67320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
67321   void * jresult ;
67322   Dali::Toolkit::ScrollBar result;
67323
67324   {
67325     try {
67326       result = Dali::Toolkit::ScrollBar::New();
67327     } catch (std::out_of_range& e) {
67328       {
67329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67330       };
67331     } catch (std::exception& e) {
67332       {
67333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67334       };
67335     } catch (...) {
67336       {
67337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67338       };
67339     }
67340   }
67341   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67342   return jresult;
67343 }
67344
67345
67346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
67347   void * jresult ;
67348   Dali::BaseHandle arg1 ;
67349   Dali::BaseHandle *argp1 ;
67350   Dali::Toolkit::ScrollBar result;
67351
67352   argp1 = (Dali::BaseHandle *)jarg1;
67353   if (!argp1) {
67354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67355     return 0;
67356   }
67357   arg1 = *argp1;
67358   {
67359     try {
67360       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
67361     } catch (std::out_of_range& e) {
67362       {
67363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67364       };
67365     } catch (std::exception& e) {
67366       {
67367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67368       };
67369     } catch (...) {
67370       {
67371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67372       };
67373     }
67374   }
67375   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67376   return jresult;
67377 }
67378
67379
67380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
67381   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67382   Dali::Handle arg2 ;
67383   Dali::Property::Index arg3 ;
67384   Dali::Property::Index arg4 ;
67385   Dali::Property::Index arg5 ;
67386   Dali::Property::Index arg6 ;
67387   Dali::Handle *argp2 ;
67388
67389   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67390   argp2 = (Dali::Handle *)jarg2;
67391   if (!argp2) {
67392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
67393     return ;
67394   }
67395   arg2 = *argp2;
67396   arg3 = (Dali::Property::Index)jarg3;
67397   arg4 = (Dali::Property::Index)jarg4;
67398   arg5 = (Dali::Property::Index)jarg5;
67399   arg6 = (Dali::Property::Index)jarg6;
67400   {
67401     try {
67402       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
67403     } catch (std::out_of_range& e) {
67404       {
67405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67406       };
67407     } catch (std::exception& e) {
67408       {
67409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67410       };
67411     } catch (...) {
67412       {
67413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67414       };
67415     }
67416   }
67417 }
67418
67419
67420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
67421   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67422   Dali::Actor arg2 ;
67423   Dali::Actor *argp2 ;
67424
67425   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67426   argp2 = (Dali::Actor *)jarg2;
67427   if (!argp2) {
67428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
67429     return ;
67430   }
67431   arg2 = *argp2;
67432   {
67433     try {
67434       (arg1)->SetScrollIndicator(arg2);
67435     } catch (std::out_of_range& e) {
67436       {
67437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67438       };
67439     } catch (std::exception& e) {
67440       {
67441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67442       };
67443     } catch (...) {
67444       {
67445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67446       };
67447     }
67448   }
67449 }
67450
67451
67452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
67453   void * jresult ;
67454   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67455   Dali::Actor result;
67456
67457   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67458   {
67459     try {
67460       result = (arg1)->GetScrollIndicator();
67461     } catch (std::out_of_range& e) {
67462       {
67463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67464       };
67465     } catch (std::exception& e) {
67466       {
67467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67468       };
67469     } catch (...) {
67470       {
67471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67472       };
67473     }
67474   }
67475   jresult = new Dali::Actor((const Dali::Actor &)result);
67476   return jresult;
67477 }
67478
67479
67480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
67481   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67482   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
67483
67484   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67485   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
67486   if (!arg2) {
67487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
67488     return ;
67489   }
67490   {
67491     try {
67492       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
67493     } catch (std::out_of_range& e) {
67494       {
67495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67496       };
67497     } catch (std::exception& e) {
67498       {
67499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67500       };
67501     } catch (...) {
67502       {
67503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67504       };
67505     }
67506   }
67507 }
67508
67509
67510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
67511   void * jresult ;
67512   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67513   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > result;
67514
67515   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67516   {
67517     try {
67518       result = ((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollPositionIntervals();
67519     } catch (std::out_of_range& e) {
67520       {
67521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67522       };
67523     } catch (std::exception& e) {
67524       {
67525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67526       };
67527     } catch (...) {
67528       {
67529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67530       };
67531     }
67532   }
67533   jresult = new Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true >((const Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > &)result);
67534   return jresult;
67535 }
67536
67537
67538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
67539   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67540   Dali::Toolkit::ScrollBar::Direction arg2 ;
67541
67542   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67543   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
67544   {
67545     try {
67546       (arg1)->SetScrollDirection(arg2);
67547     } catch (std::out_of_range& e) {
67548       {
67549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67550       };
67551     } catch (std::exception& e) {
67552       {
67553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67554       };
67555     } catch (...) {
67556       {
67557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67558       };
67559     }
67560   }
67561 }
67562
67563
67564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
67565   int jresult ;
67566   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67567   Dali::Toolkit::ScrollBar::Direction result;
67568
67569   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67570   {
67571     try {
67572       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
67573     } catch (std::out_of_range& e) {
67574       {
67575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67576       };
67577     } catch (std::exception& e) {
67578       {
67579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67580       };
67581     } catch (...) {
67582       {
67583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67584       };
67585     }
67586   }
67587   jresult = (int)result;
67588   return jresult;
67589 }
67590
67591
67592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
67593   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67594   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
67595
67596   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67597   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
67598   {
67599     try {
67600       (arg1)->SetIndicatorHeightPolicy(arg2);
67601     } catch (std::out_of_range& e) {
67602       {
67603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67604       };
67605     } catch (std::exception& e) {
67606       {
67607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67608       };
67609     } catch (...) {
67610       {
67611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67612       };
67613     }
67614   }
67615 }
67616
67617
67618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
67619   int jresult ;
67620   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67621   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
67622
67623   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67624   {
67625     try {
67626       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
67627     } catch (std::out_of_range& e) {
67628       {
67629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67630       };
67631     } catch (std::exception& e) {
67632       {
67633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67634       };
67635     } catch (...) {
67636       {
67637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67638       };
67639     }
67640   }
67641   jresult = (int)result;
67642   return jresult;
67643 }
67644
67645
67646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
67647   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67648   float arg2 ;
67649
67650   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67651   arg2 = (float)jarg2;
67652   {
67653     try {
67654       (arg1)->SetIndicatorFixedHeight(arg2);
67655     } catch (std::out_of_range& e) {
67656       {
67657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67658       };
67659     } catch (std::exception& e) {
67660       {
67661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67662       };
67663     } catch (...) {
67664       {
67665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67666       };
67667     }
67668   }
67669 }
67670
67671
67672 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
67673   float jresult ;
67674   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67675   float result;
67676
67677   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67678   {
67679     try {
67680       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
67681     } catch (std::out_of_range& e) {
67682       {
67683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67684       };
67685     } catch (std::exception& e) {
67686       {
67687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67688       };
67689     } catch (...) {
67690       {
67691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67692       };
67693     }
67694   }
67695   jresult = result;
67696   return jresult;
67697 }
67698
67699
67700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
67701   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67702   float arg2 ;
67703
67704   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67705   arg2 = (float)jarg2;
67706   {
67707     try {
67708       (arg1)->SetIndicatorShowDuration(arg2);
67709     } catch (std::out_of_range& e) {
67710       {
67711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67712       };
67713     } catch (std::exception& e) {
67714       {
67715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67716       };
67717     } catch (...) {
67718       {
67719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67720       };
67721     }
67722   }
67723 }
67724
67725
67726 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
67727   float jresult ;
67728   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67729   float result;
67730
67731   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67732   {
67733     try {
67734       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
67735     } catch (std::out_of_range& e) {
67736       {
67737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67738       };
67739     } catch (std::exception& e) {
67740       {
67741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67742       };
67743     } catch (...) {
67744       {
67745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67746       };
67747     }
67748   }
67749   jresult = result;
67750   return jresult;
67751 }
67752
67753
67754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
67755   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67756   float arg2 ;
67757
67758   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67759   arg2 = (float)jarg2;
67760   {
67761     try {
67762       (arg1)->SetIndicatorHideDuration(arg2);
67763     } catch (std::out_of_range& e) {
67764       {
67765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67766       };
67767     } catch (std::exception& e) {
67768       {
67769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67770       };
67771     } catch (...) {
67772       {
67773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67774       };
67775     }
67776   }
67777 }
67778
67779
67780 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
67781   float jresult ;
67782   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67783   float result;
67784
67785   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67786   {
67787     try {
67788       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
67789     } catch (std::out_of_range& e) {
67790       {
67791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67792       };
67793     } catch (std::exception& e) {
67794       {
67795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67796       };
67797     } catch (...) {
67798       {
67799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67800       };
67801     }
67802   }
67803   jresult = result;
67804   return jresult;
67805 }
67806
67807
67808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
67809   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67810
67811   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67812   {
67813     try {
67814       (arg1)->ShowIndicator();
67815     } catch (std::out_of_range& e) {
67816       {
67817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67818       };
67819     } catch (std::exception& e) {
67820       {
67821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67822       };
67823     } catch (...) {
67824       {
67825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67826       };
67827     }
67828   }
67829 }
67830
67831
67832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
67833   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67834
67835   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67836   {
67837     try {
67838       (arg1)->HideIndicator();
67839     } catch (std::out_of_range& e) {
67840       {
67841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67842       };
67843     } catch (std::exception& e) {
67844       {
67845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67846       };
67847     } catch (...) {
67848       {
67849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67850       };
67851     }
67852   }
67853 }
67854
67855
67856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
67857   void * jresult ;
67858   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67859   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
67860
67861   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67862   {
67863     try {
67864       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
67865     } catch (std::out_of_range& e) {
67866       {
67867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67868       };
67869     } catch (std::exception& e) {
67870       {
67871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67872       };
67873     } catch (...) {
67874       {
67875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67876       };
67877     }
67878   }
67879   jresult = (void *)result;
67880   return jresult;
67881 }
67882
67883
67884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
67885   void * jresult ;
67886   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67887   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
67888
67889   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67890   {
67891     try {
67892       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
67893     } catch (std::out_of_range& e) {
67894       {
67895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67896       };
67897     } catch (std::exception& e) {
67898       {
67899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67900       };
67901     } catch (...) {
67902       {
67903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67904       };
67905     }
67906   }
67907   jresult = (void *)result;
67908   return jresult;
67909 }
67910
67911
67912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
67913   int jresult ;
67914   int result;
67915
67916   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
67917   jresult = (int)result;
67918   return jresult;
67919 }
67920
67921
67922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
67923   int jresult ;
67924   int result;
67925
67926   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
67927   jresult = (int)result;
67928   return jresult;
67929 }
67930
67931
67932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
67933   int jresult ;
67934   int result;
67935
67936   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
67937   jresult = (int)result;
67938   return jresult;
67939 }
67940
67941
67942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
67943   int jresult ;
67944   int result;
67945
67946   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
67947   jresult = (int)result;
67948   return jresult;
67949 }
67950
67951
67952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
67953   int jresult ;
67954   int result;
67955
67956   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
67957   jresult = (int)result;
67958   return jresult;
67959 }
67960
67961
67962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
67963   int jresult ;
67964   int result;
67965
67966   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
67967   jresult = (int)result;
67968   return jresult;
67969 }
67970
67971
67972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
67973   int jresult ;
67974   int result;
67975
67976   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
67977   jresult = (int)result;
67978   return jresult;
67979 }
67980
67981
67982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
67983   int jresult ;
67984   int result;
67985
67986   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
67987   jresult = (int)result;
67988   return jresult;
67989 }
67990
67991
67992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
67993   int jresult ;
67994   int result;
67995
67996   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
67997   jresult = (int)result;
67998   return jresult;
67999 }
68000
68001
68002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
68003   int jresult ;
68004   int result;
68005
68006   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
68007   jresult = (int)result;
68008   return jresult;
68009 }
68010
68011
68012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
68013   int jresult ;
68014   int result;
68015
68016   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
68017   jresult = (int)result;
68018   return jresult;
68019 }
68020
68021
68022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
68023   int jresult ;
68024   int result;
68025
68026   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
68027   jresult = (int)result;
68028   return jresult;
68029 }
68030
68031
68032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
68033   int jresult ;
68034   int result;
68035
68036   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
68037   jresult = (int)result;
68038   return jresult;
68039 }
68040
68041
68042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
68043   int jresult ;
68044   int result;
68045
68046   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
68047   jresult = (int)result;
68048   return jresult;
68049 }
68050
68051
68052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
68053   void * jresult ;
68054   Dali::Toolkit::Scrollable::Property *result = 0 ;
68055
68056   {
68057     try {
68058       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
68059     } catch (std::out_of_range& e) {
68060       {
68061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68062       };
68063     } catch (std::exception& e) {
68064       {
68065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68066       };
68067     } catch (...) {
68068       {
68069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68070       };
68071     }
68072   }
68073   jresult = (void *)result;
68074   return jresult;
68075 }
68076
68077
68078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
68079   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
68080
68081   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
68082   {
68083     try {
68084       delete arg1;
68085     } catch (std::out_of_range& e) {
68086       {
68087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68088       };
68089     } catch (std::exception& e) {
68090       {
68091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68092       };
68093     } catch (...) {
68094       {
68095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68096       };
68097     }
68098   }
68099 }
68100
68101
68102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
68103   void * jresult ;
68104   Dali::Toolkit::Scrollable *result = 0 ;
68105
68106   {
68107     try {
68108       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
68109     } catch (std::out_of_range& e) {
68110       {
68111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68112       };
68113     } catch (std::exception& e) {
68114       {
68115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68116       };
68117     } catch (...) {
68118       {
68119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68120       };
68121     }
68122   }
68123   jresult = (void *)result;
68124   return jresult;
68125 }
68126
68127
68128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
68129   void * jresult ;
68130   Dali::Toolkit::Scrollable *arg1 = 0 ;
68131   Dali::Toolkit::Scrollable *result = 0 ;
68132
68133   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68134   if (!arg1) {
68135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68136     return 0;
68137   }
68138   {
68139     try {
68140       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
68141     } catch (std::out_of_range& e) {
68142       {
68143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68144       };
68145     } catch (std::exception& e) {
68146       {
68147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68148       };
68149     } catch (...) {
68150       {
68151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68152       };
68153     }
68154   }
68155   jresult = (void *)result;
68156   return jresult;
68157 }
68158
68159
68160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
68161   void * jresult ;
68162   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68163   Dali::Toolkit::Scrollable *arg2 = 0 ;
68164   Dali::Toolkit::Scrollable *result = 0 ;
68165
68166   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68167   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
68168   if (!arg2) {
68169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68170     return 0;
68171   }
68172   {
68173     try {
68174       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
68175     } catch (std::out_of_range& e) {
68176       {
68177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68178       };
68179     } catch (std::exception& e) {
68180       {
68181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68182       };
68183     } catch (...) {
68184       {
68185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68186       };
68187     }
68188   }
68189   jresult = (void *)result;
68190   return jresult;
68191 }
68192
68193
68194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
68195   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68196
68197   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68198   {
68199     try {
68200       delete arg1;
68201     } catch (std::out_of_range& e) {
68202       {
68203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68204       };
68205     } catch (std::exception& e) {
68206       {
68207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68208       };
68209     } catch (...) {
68210       {
68211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68212       };
68213     }
68214   }
68215 }
68216
68217
68218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
68219   void * jresult ;
68220   Dali::BaseHandle arg1 ;
68221   Dali::BaseHandle *argp1 ;
68222   Dali::Toolkit::Scrollable result;
68223
68224   argp1 = (Dali::BaseHandle *)jarg1;
68225   if (!argp1) {
68226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68227     return 0;
68228   }
68229   arg1 = *argp1;
68230   {
68231     try {
68232       result = Dali::Toolkit::Scrollable::DownCast(arg1);
68233     } catch (std::out_of_range& e) {
68234       {
68235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68236       };
68237     } catch (std::exception& e) {
68238       {
68239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68240       };
68241     } catch (...) {
68242       {
68243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68244       };
68245     }
68246   }
68247   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
68248   return jresult;
68249 }
68250
68251
68252 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
68253   unsigned int jresult ;
68254   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68255   bool result;
68256
68257   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68258   {
68259     try {
68260       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
68261     } catch (std::out_of_range& e) {
68262       {
68263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68264       };
68265     } catch (std::exception& e) {
68266       {
68267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68268       };
68269     } catch (...) {
68270       {
68271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68272       };
68273     }
68274   }
68275   jresult = result;
68276   return jresult;
68277 }
68278
68279
68280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
68281   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68282   bool arg2 ;
68283
68284   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68285   arg2 = jarg2 ? true : false;
68286   {
68287     try {
68288       (arg1)->SetOvershootEnabled(arg2);
68289     } catch (std::out_of_range& e) {
68290       {
68291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68292       };
68293     } catch (std::exception& e) {
68294       {
68295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68296       };
68297     } catch (...) {
68298       {
68299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68300       };
68301     }
68302   }
68303 }
68304
68305
68306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
68307   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68308   Dali::Vector4 *arg2 = 0 ;
68309
68310   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68311   arg2 = (Dali::Vector4 *)jarg2;
68312   if (!arg2) {
68313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
68314     return ;
68315   }
68316   {
68317     try {
68318       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
68319     } catch (std::out_of_range& e) {
68320       {
68321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68322       };
68323     } catch (std::exception& e) {
68324       {
68325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68326       };
68327     } catch (...) {
68328       {
68329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68330       };
68331     }
68332   }
68333 }
68334
68335
68336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
68337   void * jresult ;
68338   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68339   Dali::Vector4 result;
68340
68341   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68342   {
68343     try {
68344       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
68345     } catch (std::out_of_range& e) {
68346       {
68347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68348       };
68349     } catch (std::exception& e) {
68350       {
68351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68352       };
68353     } catch (...) {
68354       {
68355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68356       };
68357     }
68358   }
68359   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
68360   return jresult;
68361 }
68362
68363
68364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
68365   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68366   float arg2 ;
68367
68368   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68369   arg2 = (float)jarg2;
68370   {
68371     try {
68372       (arg1)->SetOvershootAnimationSpeed(arg2);
68373     } catch (std::out_of_range& e) {
68374       {
68375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68376       };
68377     } catch (std::exception& e) {
68378       {
68379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68380       };
68381     } catch (...) {
68382       {
68383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68384       };
68385     }
68386   }
68387 }
68388
68389
68390 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
68391   float jresult ;
68392   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68393   float result;
68394
68395   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68396   {
68397     try {
68398       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
68399     } catch (std::out_of_range& e) {
68400       {
68401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68402       };
68403     } catch (std::exception& e) {
68404       {
68405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68406       };
68407     } catch (...) {
68408       {
68409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68410       };
68411     }
68412   }
68413   jresult = result;
68414   return jresult;
68415 }
68416
68417
68418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
68419   void * jresult ;
68420   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68421   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
68422
68423   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68424   {
68425     try {
68426       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
68427     } catch (std::out_of_range& e) {
68428       {
68429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68430       };
68431     } catch (std::exception& e) {
68432       {
68433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68434       };
68435     } catch (...) {
68436       {
68437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68438       };
68439     }
68440   }
68441   jresult = (void *)result;
68442   return jresult;
68443 }
68444
68445
68446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
68447   void * jresult ;
68448   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68449   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
68450
68451   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68452   {
68453     try {
68454       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
68455     } catch (std::out_of_range& e) {
68456       {
68457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68458       };
68459     } catch (std::exception& e) {
68460       {
68461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68462       };
68463     } catch (...) {
68464       {
68465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68466       };
68467     }
68468   }
68469   jresult = (void *)result;
68470   return jresult;
68471 }
68472
68473
68474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
68475   void * jresult ;
68476   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68477   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
68478
68479   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68480   {
68481     try {
68482       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
68483     } catch (std::out_of_range& e) {
68484       {
68485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68486       };
68487     } catch (std::exception& e) {
68488       {
68489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68490       };
68491     } catch (...) {
68492       {
68493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68494       };
68495     }
68496   }
68497   jresult = (void *)result;
68498   return jresult;
68499 }
68500
68501
68502 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
68503   unsigned int jresult ;
68504   Dali::Toolkit::ControlOrientation::Type arg1 ;
68505   bool result;
68506
68507   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
68508   {
68509     try {
68510       result = (bool)Dali::Toolkit::IsVertical(arg1);
68511     } catch (std::out_of_range& e) {
68512       {
68513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68514       };
68515     } catch (std::exception& e) {
68516       {
68517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68518       };
68519     } catch (...) {
68520       {
68521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68522       };
68523     }
68524   }
68525   jresult = result;
68526   return jresult;
68527 }
68528
68529
68530 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
68531   unsigned int jresult ;
68532   Dali::Toolkit::ControlOrientation::Type arg1 ;
68533   bool result;
68534
68535   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
68536   {
68537     try {
68538       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
68539     } catch (std::out_of_range& e) {
68540       {
68541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68542       };
68543     } catch (std::exception& e) {
68544       {
68545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68546       };
68547     } catch (...) {
68548       {
68549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68550       };
68551     }
68552   }
68553   jresult = result;
68554   return jresult;
68555 }
68556
68557
68558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
68559   void * jresult ;
68560   unsigned int arg1 ;
68561   unsigned int arg2 ;
68562   Dali::Toolkit::ItemRange *result = 0 ;
68563
68564   arg1 = (unsigned int)jarg1;
68565   arg2 = (unsigned int)jarg2;
68566   {
68567     try {
68568       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
68569     } catch (std::out_of_range& e) {
68570       {
68571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68572       };
68573     } catch (std::exception& e) {
68574       {
68575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68576       };
68577     } catch (...) {
68578       {
68579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68580       };
68581     }
68582   }
68583   jresult = (void *)result;
68584   return jresult;
68585 }
68586
68587
68588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
68589   void * jresult ;
68590   Dali::Toolkit::ItemRange *arg1 = 0 ;
68591   Dali::Toolkit::ItemRange *result = 0 ;
68592
68593   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68594   if (!arg1) {
68595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68596     return 0;
68597   }
68598   {
68599     try {
68600       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
68601     } catch (std::out_of_range& e) {
68602       {
68603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68604       };
68605     } catch (std::exception& e) {
68606       {
68607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68608       };
68609     } catch (...) {
68610       {
68611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68612       };
68613     }
68614   }
68615   jresult = (void *)result;
68616   return jresult;
68617 }
68618
68619
68620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
68621   void * jresult ;
68622   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68623   Dali::Toolkit::ItemRange *arg2 = 0 ;
68624   Dali::Toolkit::ItemRange *result = 0 ;
68625
68626   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68627   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
68628   if (!arg2) {
68629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68630     return 0;
68631   }
68632   {
68633     try {
68634       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
68635     } catch (std::out_of_range& e) {
68636       {
68637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68638       };
68639     } catch (std::exception& e) {
68640       {
68641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68642       };
68643     } catch (...) {
68644       {
68645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68646       };
68647     }
68648   }
68649   jresult = (void *)result;
68650   return jresult;
68651 }
68652
68653
68654 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
68655   unsigned int jresult ;
68656   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68657   unsigned int arg2 ;
68658   bool result;
68659
68660   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68661   arg2 = (unsigned int)jarg2;
68662   {
68663     try {
68664       result = (bool)(arg1)->Within(arg2);
68665     } catch (std::out_of_range& e) {
68666       {
68667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68668       };
68669     } catch (std::exception& e) {
68670       {
68671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68672       };
68673     } catch (...) {
68674       {
68675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68676       };
68677     }
68678   }
68679   jresult = result;
68680   return jresult;
68681 }
68682
68683
68684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
68685   void * jresult ;
68686   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68687   Dali::Toolkit::ItemRange *arg2 = 0 ;
68688   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
68689
68690   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68691   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
68692   if (!arg2) {
68693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68694     return 0;
68695   }
68696   {
68697     try {
68698       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
68699     } catch (std::out_of_range& e) {
68700       {
68701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68702       };
68703     } catch (std::exception& e) {
68704       {
68705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68706       };
68707     } catch (...) {
68708       {
68709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68710       };
68711     }
68712   }
68713   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
68714   return jresult;
68715 }
68716
68717
68718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
68719   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68720   unsigned int arg2 ;
68721
68722   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68723   arg2 = (unsigned int)jarg2;
68724   if (arg1) (arg1)->begin = arg2;
68725 }
68726
68727
68728 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
68729   unsigned int jresult ;
68730   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68731   unsigned int result;
68732
68733   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68734   result = (unsigned int) ((arg1)->begin);
68735   jresult = result;
68736   return jresult;
68737 }
68738
68739
68740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
68741   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68742   unsigned int arg2 ;
68743
68744   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68745   arg2 = (unsigned int)jarg2;
68746   if (arg1) (arg1)->end = arg2;
68747 }
68748
68749
68750 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
68751   unsigned int jresult ;
68752   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68753   unsigned int result;
68754
68755   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68756   result = (unsigned int) ((arg1)->end);
68757   jresult = result;
68758   return jresult;
68759 }
68760
68761
68762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
68763   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68764
68765   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68766   {
68767     try {
68768       delete arg1;
68769     } catch (std::out_of_range& e) {
68770       {
68771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68772       };
68773     } catch (std::exception& e) {
68774       {
68775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68776       };
68777     } catch (...) {
68778       {
68779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68780       };
68781     }
68782   }
68783 }
68784
68785
68786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
68787   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68788
68789   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68790   {
68791     try {
68792       delete arg1;
68793     } catch (std::out_of_range& e) {
68794       {
68795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68796       };
68797     } catch (std::exception& e) {
68798       {
68799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68800       };
68801     } catch (...) {
68802       {
68803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68804       };
68805     }
68806   }
68807 }
68808
68809
68810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
68811   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68812   Dali::Toolkit::ControlOrientation::Type arg2 ;
68813
68814   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68815   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
68816   {
68817     try {
68818       (arg1)->SetOrientation(arg2);
68819     } catch (std::out_of_range& e) {
68820       {
68821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68822       };
68823     } catch (std::exception& e) {
68824       {
68825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68826       };
68827     } catch (...) {
68828       {
68829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68830       };
68831     }
68832   }
68833 }
68834
68835
68836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
68837   int jresult ;
68838   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68839   Dali::Toolkit::ControlOrientation::Type result;
68840
68841   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68842   {
68843     try {
68844       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
68845     } catch (std::out_of_range& e) {
68846       {
68847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68848       };
68849     } catch (std::exception& e) {
68850       {
68851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68852       };
68853     } catch (...) {
68854       {
68855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68856       };
68857     }
68858   }
68859   jresult = (int)result;
68860   return jresult;
68861 }
68862
68863
68864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
68865   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68866   Dali::Property::Map *arg2 = 0 ;
68867
68868   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68869   arg2 = (Dali::Property::Map *)jarg2;
68870   if (!arg2) {
68871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
68872     return ;
68873   }
68874   {
68875     try {
68876       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
68877     } catch (std::out_of_range& e) {
68878       {
68879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68880       };
68881     } catch (std::exception& e) {
68882       {
68883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68884       };
68885     } catch (...) {
68886       {
68887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68888       };
68889     }
68890   }
68891 }
68892
68893
68894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
68895   void * jresult ;
68896   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68897   Dali::Property::Map result;
68898
68899   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68900   {
68901     try {
68902       result = (arg1)->GetLayoutProperties();
68903     } catch (std::out_of_range& e) {
68904       {
68905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68906       };
68907     } catch (std::exception& e) {
68908       {
68909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68910       };
68911     } catch (...) {
68912       {
68913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68914       };
68915     }
68916   }
68917   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
68918   return jresult;
68919 }
68920
68921
68922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
68923   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68924   unsigned int arg2 ;
68925   Dali::Vector3 *arg3 = 0 ;
68926   Dali::Vector3 *arg4 = 0 ;
68927
68928   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68929   arg2 = (unsigned int)jarg2;
68930   arg3 = (Dali::Vector3 *)jarg3;
68931   if (!arg3) {
68932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68933     return ;
68934   }
68935   arg4 = (Dali::Vector3 *)jarg4;
68936   if (!arg4) {
68937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
68938     return ;
68939   }
68940   {
68941     try {
68942       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
68943     } catch (std::out_of_range& e) {
68944       {
68945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68946       };
68947     } catch (std::exception& e) {
68948       {
68949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68950       };
68951     } catch (...) {
68952       {
68953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68954       };
68955     }
68956   }
68957 }
68958
68959
68960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
68961   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68962   Dali::Vector3 *arg2 = 0 ;
68963
68964   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68965   arg2 = (Dali::Vector3 *)jarg2;
68966   if (!arg2) {
68967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68968     return ;
68969   }
68970   {
68971     try {
68972       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
68973     } catch (std::out_of_range& e) {
68974       {
68975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68976       };
68977     } catch (std::exception& e) {
68978       {
68979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68980       };
68981     } catch (...) {
68982       {
68983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68984       };
68985     }
68986   }
68987 }
68988
68989
68990 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
68991   float jresult ;
68992   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68993   unsigned int arg2 ;
68994   Dali::Vector3 arg3 ;
68995   Dali::Vector3 *argp3 ;
68996   float result;
68997
68998   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68999   arg2 = (unsigned int)jarg2;
69000   argp3 = (Dali::Vector3 *)jarg3;
69001   if (!argp3) {
69002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69003     return 0;
69004   }
69005   arg3 = *argp3;
69006   {
69007     try {
69008       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
69009     } catch (std::out_of_range& e) {
69010       {
69011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69012       };
69013     } catch (std::exception& e) {
69014       {
69015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69016       };
69017     } catch (...) {
69018       {
69019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69020       };
69021     }
69022   }
69023   jresult = result;
69024   return jresult;
69025 }
69026
69027
69028 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
69029   float jresult ;
69030   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69031   float arg2 ;
69032   float result;
69033
69034   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69035   arg2 = (float)jarg2;
69036   {
69037     try {
69038       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
69039     } catch (std::out_of_range& e) {
69040       {
69041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69042       };
69043     } catch (std::exception& e) {
69044       {
69045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69046       };
69047     } catch (...) {
69048       {
69049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69050       };
69051     }
69052   }
69053   jresult = result;
69054   return jresult;
69055 }
69056
69057
69058 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
69059   float jresult ;
69060   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69061   unsigned int arg2 ;
69062   float result;
69063
69064   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69065   arg2 = (unsigned int)jarg2;
69066   {
69067     try {
69068       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
69069     } catch (std::out_of_range& e) {
69070       {
69071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69072       };
69073     } catch (std::exception& e) {
69074       {
69075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69076       };
69077     } catch (...) {
69078       {
69079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69080       };
69081     }
69082   }
69083   jresult = result;
69084   return jresult;
69085 }
69086
69087
69088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
69089   void * jresult ;
69090   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69091   float arg2 ;
69092   Dali::Vector3 arg3 ;
69093   Dali::Vector3 *argp3 ;
69094   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69095
69096   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69097   arg2 = (float)jarg2;
69098   argp3 = (Dali::Vector3 *)jarg3;
69099   if (!argp3) {
69100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69101     return 0;
69102   }
69103   arg3 = *argp3;
69104   {
69105     try {
69106       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
69107     } catch (std::out_of_range& e) {
69108       {
69109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69110       };
69111     } catch (std::exception& e) {
69112       {
69113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69114       };
69115     } catch (...) {
69116       {
69117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69118       };
69119     }
69120   }
69121   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69122   return jresult;
69123 }
69124
69125
69126 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
69127   float jresult ;
69128   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69129   int arg2 ;
69130   float arg3 ;
69131   Dali::Vector3 *arg4 = 0 ;
69132   float result;
69133
69134   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69135   arg2 = (int)jarg2;
69136   arg3 = (float)jarg3;
69137   arg4 = (Dali::Vector3 *)jarg4;
69138   if (!arg4) {
69139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69140     return 0;
69141   }
69142   {
69143     try {
69144       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
69145     } catch (std::out_of_range& e) {
69146       {
69147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69148       };
69149     } catch (std::exception& e) {
69150       {
69151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69152       };
69153     } catch (...) {
69154       {
69155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69156       };
69157     }
69158   }
69159   jresult = result;
69160   return jresult;
69161 }
69162
69163
69164 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
69165   unsigned int jresult ;
69166   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69167   Dali::Vector3 arg2 ;
69168   Dali::Vector3 *argp2 ;
69169   unsigned int result;
69170
69171   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69172   argp2 = (Dali::Vector3 *)jarg2;
69173   if (!argp2) {
69174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69175     return 0;
69176   }
69177   arg2 = *argp2;
69178   {
69179     try {
69180       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
69181     } catch (std::out_of_range& e) {
69182       {
69183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69184       };
69185     } catch (std::exception& e) {
69186       {
69187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69188       };
69189     } catch (...) {
69190       {
69191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69192       };
69193     }
69194   }
69195   jresult = result;
69196   return jresult;
69197 }
69198
69199
69200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69201   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69202   unsigned int arg2 ;
69203   Dali::Vector3 *arg3 = 0 ;
69204   Dali::Vector3 *arg4 = 0 ;
69205
69206   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69207   arg2 = (unsigned int)jarg2;
69208   arg3 = (Dali::Vector3 *)jarg3;
69209   if (!arg3) {
69210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69211     return ;
69212   }
69213   arg4 = (Dali::Vector3 *)jarg4;
69214   if (!arg4) {
69215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69216     return ;
69217   }
69218   {
69219     try {
69220       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69221     } catch (std::out_of_range& e) {
69222       {
69223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69224       };
69225     } catch (std::exception& e) {
69226       {
69227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69228       };
69229     } catch (...) {
69230       {
69231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69232       };
69233     }
69234   }
69235 }
69236
69237
69238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
69239   void * jresult ;
69240   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69241   Dali::Degree result;
69242
69243   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69244   {
69245     try {
69246       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
69247     } catch (std::out_of_range& e) {
69248       {
69249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69250       };
69251     } catch (std::exception& e) {
69252       {
69253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69254       };
69255     } catch (...) {
69256       {
69257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69258       };
69259     }
69260   }
69261   jresult = new Dali::Degree((const Dali::Degree &)result);
69262   return jresult;
69263 }
69264
69265
69266 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
69267   float jresult ;
69268   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69269   float result;
69270
69271   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69272   {
69273     try {
69274       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
69275     } catch (std::out_of_range& e) {
69276       {
69277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69278       };
69279     } catch (std::exception& e) {
69280       {
69281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69282       };
69283     } catch (...) {
69284       {
69285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69286       };
69287     }
69288   }
69289   jresult = result;
69290   return jresult;
69291 }
69292
69293
69294 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
69295   float jresult ;
69296   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69297   float result;
69298
69299   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69300   {
69301     try {
69302       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
69303     } catch (std::out_of_range& e) {
69304       {
69305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69306       };
69307     } catch (std::exception& e) {
69308       {
69309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69310       };
69311     } catch (...) {
69312       {
69313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69314       };
69315     }
69316   }
69317   jresult = result;
69318   return jresult;
69319 }
69320
69321
69322 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
69323   float jresult ;
69324   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69325   float result;
69326
69327   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69328   {
69329     try {
69330       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
69331     } catch (std::out_of_range& e) {
69332       {
69333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69334       };
69335     } catch (std::exception& e) {
69336       {
69337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69338       };
69339     } catch (...) {
69340       {
69341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69342       };
69343     }
69344   }
69345   jresult = result;
69346   return jresult;
69347 }
69348
69349
69350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
69351   int jresult ;
69352   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69353   int arg2 ;
69354   int arg3 ;
69355   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
69356   bool arg5 ;
69357   int result;
69358
69359   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69360   arg2 = (int)jarg2;
69361   arg3 = (int)jarg3;
69362   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
69363   arg5 = jarg5 ? true : false;
69364   {
69365     try {
69366       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
69367     } catch (std::out_of_range& e) {
69368       {
69369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69370       };
69371     } catch (std::exception& e) {
69372       {
69373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69374       };
69375     } catch (...) {
69376       {
69377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69378       };
69379     }
69380   }
69381   jresult = result;
69382   return jresult;
69383 }
69384
69385
69386 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
69387   float jresult ;
69388   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69389   float result;
69390
69391   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69392   {
69393     try {
69394       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
69395     } catch (std::out_of_range& e) {
69396       {
69397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69398       };
69399     } catch (std::exception& e) {
69400       {
69401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69402       };
69403     } catch (...) {
69404       {
69405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69406       };
69407     }
69408   }
69409   jresult = result;
69410   return jresult;
69411 }
69412
69413
69414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
69415   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69416   Dali::Actor *arg2 = 0 ;
69417   int arg3 ;
69418   Dali::Vector3 *arg4 = 0 ;
69419   Dali::Actor *arg5 = 0 ;
69420
69421   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69422   arg2 = (Dali::Actor *)jarg2;
69423   if (!arg2) {
69424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
69425     return ;
69426   }
69427   arg3 = (int)jarg3;
69428   arg4 = (Dali::Vector3 *)jarg4;
69429   if (!arg4) {
69430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69431     return ;
69432   }
69433   arg5 = (Dali::Actor *)jarg5;
69434   if (!arg5) {
69435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
69436     return ;
69437   }
69438   {
69439     try {
69440       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
69441     } catch (std::out_of_range& e) {
69442       {
69443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69444       };
69445     } catch (std::exception& e) {
69446       {
69447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69448       };
69449     } catch (...) {
69450       {
69451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69452       };
69453     }
69454   }
69455 }
69456
69457
69458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
69459   void * jresult ;
69460   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69461   int arg2 ;
69462   float arg3 ;
69463   Dali::Vector3 *arg4 = 0 ;
69464   Dali::Vector3 result;
69465
69466   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69467   arg2 = (int)jarg2;
69468   arg3 = (float)jarg3;
69469   arg4 = (Dali::Vector3 *)jarg4;
69470   if (!arg4) {
69471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69472     return 0;
69473   }
69474   {
69475     try {
69476       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
69477     } catch (std::out_of_range& e) {
69478       {
69479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69480       };
69481     } catch (std::exception& e) {
69482       {
69483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69484       };
69485     } catch (...) {
69486       {
69487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69488       };
69489     }
69490   }
69491   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
69492   return jresult;
69493 }
69494
69495
69496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
69497   void * jresult ;
69498   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
69499   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
69500
69501   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
69502   {
69503     try {
69504       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
69505     } catch (std::out_of_range& e) {
69506       {
69507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69508       };
69509     } catch (std::exception& e) {
69510       {
69511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69512       };
69513     } catch (...) {
69514       {
69515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69516       };
69517     }
69518   }
69519   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
69520   return jresult;
69521 }
69522
69523
69524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
69525   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69526
69527   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69528   {
69529     try {
69530       delete arg1;
69531     } catch (std::out_of_range& e) {
69532       {
69533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69534       };
69535     } catch (std::exception& e) {
69536       {
69537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69538       };
69539     } catch (...) {
69540       {
69541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69542       };
69543     }
69544   }
69545 }
69546
69547
69548 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
69549   unsigned int jresult ;
69550   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69551   unsigned int result;
69552
69553   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69554   {
69555     try {
69556       result = (unsigned int)(arg1)->GetNumberOfItems();
69557     } catch (std::out_of_range& e) {
69558       {
69559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69560       };
69561     } catch (std::exception& e) {
69562       {
69563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69564       };
69565     } catch (...) {
69566       {
69567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69568       };
69569     }
69570   }
69571   jresult = result;
69572   return jresult;
69573 }
69574
69575
69576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
69577   void * jresult ;
69578   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69579   unsigned int arg2 ;
69580   Dali::Actor result;
69581
69582   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69583   arg2 = (unsigned int)jarg2;
69584   {
69585     try {
69586       result = (arg1)->NewItem(arg2);
69587     } catch (std::out_of_range& e) {
69588       {
69589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69590       };
69591     } catch (std::exception& e) {
69592       {
69593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69594       };
69595     } catch (...) {
69596       {
69597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69598       };
69599     }
69600   }
69601   jresult = new Dali::Actor((const Dali::Actor &)result);
69602   return jresult;
69603 }
69604
69605
69606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
69607   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69608   unsigned int arg2 ;
69609   Dali::Actor arg3 ;
69610   Dali::Actor *argp3 ;
69611
69612   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69613   arg2 = (unsigned int)jarg2;
69614   argp3 = (Dali::Actor *)jarg3;
69615   if (!argp3) {
69616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69617     return ;
69618   }
69619   arg3 = *argp3;
69620   {
69621     try {
69622       (arg1)->ItemReleased(arg2,arg3);
69623     } catch (std::out_of_range& e) {
69624       {
69625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69626       };
69627     } catch (std::exception& e) {
69628       {
69629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69630       };
69631     } catch (...) {
69632       {
69633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69634       };
69635     }
69636   }
69637 }
69638
69639
69640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
69641   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69642   unsigned int arg2 ;
69643   Dali::Actor arg3 ;
69644   Dali::Actor *argp3 ;
69645
69646   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69647   arg2 = (unsigned int)jarg2;
69648   argp3 = (Dali::Actor *)jarg3;
69649   if (!argp3) {
69650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69651     return ;
69652   }
69653   arg3 = *argp3;
69654   {
69655     try {
69656       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
69657     } catch (std::out_of_range& e) {
69658       {
69659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69660       };
69661     } catch (std::exception& e) {
69662       {
69663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69664       };
69665     } catch (...) {
69666       {
69667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69668       };
69669     }
69670   }
69671 }
69672
69673
69674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
69675   void * jresult ;
69676   Dali::Toolkit::ItemFactory *result = 0 ;
69677
69678   {
69679     try {
69680       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
69681     } catch (std::out_of_range& e) {
69682       {
69683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69684       };
69685     } catch (std::exception& e) {
69686       {
69687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69688       };
69689     } catch (...) {
69690       {
69691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69692       };
69693     }
69694   }
69695   jresult = (void *)result;
69696   return jresult;
69697 }
69698
69699
69700 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) {
69701   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
69702   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
69703   if (director) {
69704     director->swig_connect_director(callback0, callback1, callback2);
69705   }
69706 }
69707
69708
69709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
69710   int jresult ;
69711   int result;
69712
69713   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
69714   jresult = (int)result;
69715   return jresult;
69716 }
69717
69718
69719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
69720   int jresult ;
69721   int result;
69722
69723   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
69724   jresult = (int)result;
69725   return jresult;
69726 }
69727
69728
69729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
69730   int jresult ;
69731   int result;
69732
69733   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
69734   jresult = (int)result;
69735   return jresult;
69736 }
69737
69738
69739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
69740   int jresult ;
69741   int result;
69742
69743   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
69744   jresult = (int)result;
69745   return jresult;
69746 }
69747
69748
69749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
69750   int jresult ;
69751   int result;
69752
69753   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
69754   jresult = (int)result;
69755   return jresult;
69756 }
69757
69758
69759 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
69760   int jresult ;
69761   int result;
69762
69763   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
69764   jresult = (int)result;
69765   return jresult;
69766 }
69767
69768
69769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
69770   int jresult ;
69771   int result;
69772
69773   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
69774   jresult = (int)result;
69775   return jresult;
69776 }
69777
69778
69779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
69780   int jresult ;
69781   int result;
69782
69783   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
69784   jresult = (int)result;
69785   return jresult;
69786 }
69787
69788
69789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
69790   int jresult ;
69791   int result;
69792
69793   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
69794   jresult = (int)result;
69795   return jresult;
69796 }
69797
69798
69799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
69800   int jresult ;
69801   int result;
69802
69803   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
69804   jresult = (int)result;
69805   return jresult;
69806 }
69807
69808
69809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
69810   int jresult ;
69811   int result;
69812
69813   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
69814   jresult = (int)result;
69815   return jresult;
69816 }
69817
69818
69819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
69820   void * jresult ;
69821   Dali::Toolkit::ItemView::Property *result = 0 ;
69822
69823   {
69824     try {
69825       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
69826     } catch (std::out_of_range& e) {
69827       {
69828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69829       };
69830     } catch (std::exception& e) {
69831       {
69832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69833       };
69834     } catch (...) {
69835       {
69836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69837       };
69838     }
69839   }
69840   jresult = (void *)result;
69841   return jresult;
69842 }
69843
69844
69845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
69846   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
69847
69848   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
69849   {
69850     try {
69851       delete arg1;
69852     } catch (std::out_of_range& e) {
69853       {
69854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69855       };
69856     } catch (std::exception& e) {
69857       {
69858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69859       };
69860     } catch (...) {
69861       {
69862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69863       };
69864     }
69865   }
69866 }
69867
69868
69869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
69870   void * jresult ;
69871   Dali::Toolkit::ItemView *result = 0 ;
69872
69873   {
69874     try {
69875       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
69876     } catch (std::out_of_range& e) {
69877       {
69878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69879       };
69880     } catch (std::exception& e) {
69881       {
69882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69883       };
69884     } catch (...) {
69885       {
69886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69887       };
69888     }
69889   }
69890   jresult = (void *)result;
69891   return jresult;
69892 }
69893
69894
69895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
69896   void * jresult ;
69897   Dali::Toolkit::ItemView *arg1 = 0 ;
69898   Dali::Toolkit::ItemView *result = 0 ;
69899
69900   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69901   if (!arg1) {
69902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
69903     return 0;
69904   }
69905   {
69906     try {
69907       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
69908     } catch (std::out_of_range& e) {
69909       {
69910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69911       };
69912     } catch (std::exception& e) {
69913       {
69914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69915       };
69916     } catch (...) {
69917       {
69918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69919       };
69920     }
69921   }
69922   jresult = (void *)result;
69923   return jresult;
69924 }
69925
69926
69927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
69928   void * jresult ;
69929   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69930   Dali::Toolkit::ItemView *arg2 = 0 ;
69931   Dali::Toolkit::ItemView *result = 0 ;
69932
69933   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69934   arg2 = (Dali::Toolkit::ItemView *)jarg2;
69935   if (!arg2) {
69936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
69937     return 0;
69938   }
69939   {
69940     try {
69941       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
69942     } catch (std::out_of_range& e) {
69943       {
69944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69945       };
69946     } catch (std::exception& e) {
69947       {
69948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69949       };
69950     } catch (...) {
69951       {
69952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69953       };
69954     }
69955   }
69956   jresult = (void *)result;
69957   return jresult;
69958 }
69959
69960
69961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
69962   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69963
69964   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69965   {
69966     try {
69967       delete arg1;
69968     } catch (std::out_of_range& e) {
69969       {
69970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69971       };
69972     } catch (std::exception& e) {
69973       {
69974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69975       };
69976     } catch (...) {
69977       {
69978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69979       };
69980     }
69981   }
69982 }
69983
69984
69985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
69986   void * jresult ;
69987   Dali::Toolkit::ItemFactory *arg1 = 0 ;
69988   Dali::Toolkit::ItemView result;
69989
69990   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69991   if (!arg1) {
69992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
69993     return 0;
69994   }
69995   {
69996     try {
69997       result = Dali::Toolkit::ItemView::New(*arg1);
69998     } catch (std::out_of_range& e) {
69999       {
70000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70001       };
70002     } catch (std::exception& e) {
70003       {
70004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70005       };
70006     } catch (...) {
70007       {
70008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70009       };
70010     }
70011   }
70012   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70013   return jresult;
70014 }
70015
70016
70017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
70018   void * jresult ;
70019   Dali::BaseHandle arg1 ;
70020   Dali::BaseHandle *argp1 ;
70021   Dali::Toolkit::ItemView result;
70022
70023   argp1 = (Dali::BaseHandle *)jarg1;
70024   if (!argp1) {
70025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70026     return 0;
70027   }
70028   arg1 = *argp1;
70029   {
70030     try {
70031       result = Dali::Toolkit::ItemView::DownCast(arg1);
70032     } catch (std::out_of_range& e) {
70033       {
70034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70035       };
70036     } catch (std::exception& e) {
70037       {
70038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70039       };
70040     } catch (...) {
70041       {
70042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70043       };
70044     }
70045   }
70046   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70047   return jresult;
70048 }
70049
70050
70051 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
70052   unsigned int jresult ;
70053   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70054   unsigned int result;
70055
70056   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70057   {
70058     try {
70059       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
70060     } catch (std::out_of_range& e) {
70061       {
70062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70063       };
70064     } catch (std::exception& e) {
70065       {
70066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70067       };
70068     } catch (...) {
70069       {
70070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70071       };
70072     }
70073   }
70074   jresult = result;
70075   return jresult;
70076 }
70077
70078
70079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
70080   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70081   Dali::Toolkit::ItemLayout *arg2 = 0 ;
70082
70083   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70084   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
70085   if (!arg2) {
70086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
70087     return ;
70088   }
70089   {
70090     try {
70091       (arg1)->AddLayout(*arg2);
70092     } catch (std::out_of_range& e) {
70093       {
70094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70095       };
70096     } catch (std::exception& e) {
70097       {
70098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70099       };
70100     } catch (...) {
70101       {
70102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70103       };
70104     }
70105   }
70106 }
70107
70108
70109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
70110   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70111   unsigned int arg2 ;
70112
70113   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70114   arg2 = (unsigned int)jarg2;
70115   {
70116     try {
70117       (arg1)->RemoveLayout(arg2);
70118     } catch (std::out_of_range& e) {
70119       {
70120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70121       };
70122     } catch (std::exception& e) {
70123       {
70124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70125       };
70126     } catch (...) {
70127       {
70128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70129       };
70130     }
70131   }
70132 }
70133
70134
70135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
70136   void * jresult ;
70137   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70138   unsigned int arg2 ;
70139   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70140
70141   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70142   arg2 = (unsigned int)jarg2;
70143   {
70144     try {
70145       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
70146     } catch (std::out_of_range& e) {
70147       {
70148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70149       };
70150     } catch (std::exception& e) {
70151       {
70152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70153       };
70154     } catch (...) {
70155       {
70156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70157       };
70158     }
70159   }
70160   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70161   return jresult;
70162 }
70163
70164
70165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
70166   void * jresult ;
70167   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70168   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70169
70170   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70171   {
70172     try {
70173       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
70174     } catch (std::out_of_range& e) {
70175       {
70176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70177       };
70178     } catch (std::exception& e) {
70179       {
70180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70181       };
70182     } catch (...) {
70183       {
70184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70185       };
70186     }
70187   }
70188   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70189   return jresult;
70190 }
70191
70192
70193 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
70194   float jresult ;
70195   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70196   Dali::Toolkit::ItemId arg2 ;
70197   float result;
70198
70199   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70200   arg2 = (Dali::Toolkit::ItemId)jarg2;
70201   {
70202     try {
70203       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
70204     } catch (std::out_of_range& e) {
70205       {
70206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70207       };
70208     } catch (std::exception& e) {
70209       {
70210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70211       };
70212     } catch (...) {
70213       {
70214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70215       };
70216     }
70217   }
70218   jresult = result;
70219   return jresult;
70220 }
70221
70222
70223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
70224   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70225   unsigned int arg2 ;
70226   Dali::Vector3 arg3 ;
70227   float arg4 ;
70228   Dali::Vector3 *argp3 ;
70229
70230   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70231   arg2 = (unsigned int)jarg2;
70232   argp3 = (Dali::Vector3 *)jarg3;
70233   if (!argp3) {
70234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
70235     return ;
70236   }
70237   arg3 = *argp3;
70238   arg4 = (float)jarg4;
70239   {
70240     try {
70241       (arg1)->ActivateLayout(arg2,arg3,arg4);
70242     } catch (std::out_of_range& e) {
70243       {
70244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70245       };
70246     } catch (std::exception& e) {
70247       {
70248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70249       };
70250     } catch (...) {
70251       {
70252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70253       };
70254     }
70255   }
70256 }
70257
70258
70259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
70260   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70261
70262   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70263   {
70264     try {
70265       (arg1)->DeactivateCurrentLayout();
70266     } catch (std::out_of_range& e) {
70267       {
70268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70269       };
70270     } catch (std::exception& e) {
70271       {
70272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70273       };
70274     } catch (...) {
70275       {
70276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70277       };
70278     }
70279   }
70280 }
70281
70282
70283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
70284   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70285   float arg2 ;
70286
70287   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70288   arg2 = (float)jarg2;
70289   {
70290     try {
70291       (arg1)->SetMinimumSwipeSpeed(arg2);
70292     } catch (std::out_of_range& e) {
70293       {
70294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70295       };
70296     } catch (std::exception& e) {
70297       {
70298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70299       };
70300     } catch (...) {
70301       {
70302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70303       };
70304     }
70305   }
70306 }
70307
70308
70309 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
70310   float jresult ;
70311   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70312   float result;
70313
70314   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70315   {
70316     try {
70317       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
70318     } catch (std::out_of_range& e) {
70319       {
70320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70321       };
70322     } catch (std::exception& e) {
70323       {
70324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70325       };
70326     } catch (...) {
70327       {
70328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70329       };
70330     }
70331   }
70332   jresult = result;
70333   return jresult;
70334 }
70335
70336
70337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
70338   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70339   float arg2 ;
70340
70341   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70342   arg2 = (float)jarg2;
70343   {
70344     try {
70345       (arg1)->SetMinimumSwipeDistance(arg2);
70346     } catch (std::out_of_range& e) {
70347       {
70348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70349       };
70350     } catch (std::exception& e) {
70351       {
70352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70353       };
70354     } catch (...) {
70355       {
70356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70357       };
70358     }
70359   }
70360 }
70361
70362
70363 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
70364   float jresult ;
70365   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70366   float result;
70367
70368   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70369   {
70370     try {
70371       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
70372     } catch (std::out_of_range& e) {
70373       {
70374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70375       };
70376     } catch (std::exception& e) {
70377       {
70378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70379       };
70380     } catch (...) {
70381       {
70382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70383       };
70384     }
70385   }
70386   jresult = result;
70387   return jresult;
70388 }
70389
70390
70391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
70392   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70393   float arg2 ;
70394
70395   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70396   arg2 = (float)jarg2;
70397   {
70398     try {
70399       (arg1)->SetWheelScrollDistanceStep(arg2);
70400     } catch (std::out_of_range& e) {
70401       {
70402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70403       };
70404     } catch (std::exception& e) {
70405       {
70406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70407       };
70408     } catch (...) {
70409       {
70410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70411       };
70412     }
70413   }
70414 }
70415
70416
70417 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
70418   float jresult ;
70419   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70420   float result;
70421
70422   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70423   {
70424     try {
70425       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
70426     } catch (std::out_of_range& e) {
70427       {
70428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70429       };
70430     } catch (std::exception& e) {
70431       {
70432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70433       };
70434     } catch (...) {
70435       {
70436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70437       };
70438     }
70439   }
70440   jresult = result;
70441   return jresult;
70442 }
70443
70444
70445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
70446   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70447   bool arg2 ;
70448
70449   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70450   arg2 = jarg2 ? true : false;
70451   {
70452     try {
70453       (arg1)->SetAnchoring(arg2);
70454     } catch (std::out_of_range& e) {
70455       {
70456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70457       };
70458     } catch (std::exception& e) {
70459       {
70460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70461       };
70462     } catch (...) {
70463       {
70464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70465       };
70466     }
70467   }
70468 }
70469
70470
70471 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
70472   unsigned int jresult ;
70473   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70474   bool result;
70475
70476   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70477   {
70478     try {
70479       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
70480     } catch (std::out_of_range& e) {
70481       {
70482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70483       };
70484     } catch (std::exception& e) {
70485       {
70486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70487       };
70488     } catch (...) {
70489       {
70490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70491       };
70492     }
70493   }
70494   jresult = result;
70495   return jresult;
70496 }
70497
70498
70499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
70500   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70501   float arg2 ;
70502
70503   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70504   arg2 = (float)jarg2;
70505   {
70506     try {
70507       (arg1)->SetAnchoringDuration(arg2);
70508     } catch (std::out_of_range& e) {
70509       {
70510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70511       };
70512     } catch (std::exception& e) {
70513       {
70514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70515       };
70516     } catch (...) {
70517       {
70518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70519       };
70520     }
70521   }
70522 }
70523
70524
70525 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
70526   float jresult ;
70527   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70528   float result;
70529
70530   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70531   {
70532     try {
70533       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
70534     } catch (std::out_of_range& e) {
70535       {
70536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70537       };
70538     } catch (std::exception& e) {
70539       {
70540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70541       };
70542     } catch (...) {
70543       {
70544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70545       };
70546     }
70547   }
70548   jresult = result;
70549   return jresult;
70550 }
70551
70552
70553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
70554   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70555   Dali::Toolkit::ItemId arg2 ;
70556   float arg3 ;
70557
70558   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70559   arg2 = (Dali::Toolkit::ItemId)jarg2;
70560   arg3 = (float)jarg3;
70561   {
70562     try {
70563       (arg1)->ScrollToItem(arg2,arg3);
70564     } catch (std::out_of_range& e) {
70565       {
70566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70567       };
70568     } catch (std::exception& e) {
70569       {
70570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70571       };
70572     } catch (...) {
70573       {
70574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70575       };
70576     }
70577   }
70578 }
70579
70580
70581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
70582   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70583   float arg2 ;
70584
70585   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70586   arg2 = (float)jarg2;
70587   {
70588     try {
70589       (arg1)->SetRefreshInterval(arg2);
70590     } catch (std::out_of_range& e) {
70591       {
70592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70593       };
70594     } catch (std::exception& e) {
70595       {
70596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70597       };
70598     } catch (...) {
70599       {
70600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70601       };
70602     }
70603   }
70604 }
70605
70606
70607 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
70608   float jresult ;
70609   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70610   float result;
70611
70612   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70613   {
70614     try {
70615       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
70616     } catch (std::out_of_range& e) {
70617       {
70618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70619       };
70620     } catch (std::exception& e) {
70621       {
70622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70623       };
70624     } catch (...) {
70625       {
70626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70627       };
70628     }
70629   }
70630   jresult = result;
70631   return jresult;
70632 }
70633
70634
70635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
70636   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70637
70638   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70639   {
70640     try {
70641       (arg1)->Refresh();
70642     } catch (std::out_of_range& e) {
70643       {
70644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70645       };
70646     } catch (std::exception& e) {
70647       {
70648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70649       };
70650     } catch (...) {
70651       {
70652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70653       };
70654     }
70655   }
70656 }
70657
70658
70659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
70660   void * jresult ;
70661   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70662   Dali::Toolkit::ItemId arg2 ;
70663   Dali::Actor result;
70664
70665   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70666   arg2 = (Dali::Toolkit::ItemId)jarg2;
70667   {
70668     try {
70669       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
70670     } catch (std::out_of_range& e) {
70671       {
70672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70673       };
70674     } catch (std::exception& e) {
70675       {
70676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70677       };
70678     } catch (...) {
70679       {
70680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70681       };
70682     }
70683   }
70684   jresult = new Dali::Actor((const Dali::Actor &)result);
70685   return jresult;
70686 }
70687
70688
70689 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
70690   unsigned int jresult ;
70691   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70692   Dali::Actor arg2 ;
70693   Dali::Actor *argp2 ;
70694   Dali::Toolkit::ItemId result;
70695
70696   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70697   argp2 = (Dali::Actor *)jarg2;
70698   if (!argp2) {
70699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70700     return 0;
70701   }
70702   arg2 = *argp2;
70703   {
70704     try {
70705       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
70706     } catch (std::out_of_range& e) {
70707       {
70708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70709       };
70710     } catch (std::exception& e) {
70711       {
70712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70713       };
70714     } catch (...) {
70715       {
70716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70717       };
70718     }
70719   }
70720   jresult = result;
70721   return jresult;
70722 }
70723
70724
70725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
70726   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70727   Dali::Toolkit::Item arg2 ;
70728   float arg3 ;
70729   Dali::Toolkit::Item *argp2 ;
70730
70731   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70732   argp2 = (Dali::Toolkit::Item *)jarg2;
70733   if (!argp2) {
70734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
70735     return ;
70736   }
70737   arg2 = *argp2;
70738   arg3 = (float)jarg3;
70739   {
70740     try {
70741       (arg1)->InsertItem(arg2,arg3);
70742     } catch (std::out_of_range& e) {
70743       {
70744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70745       };
70746     } catch (std::exception& e) {
70747       {
70748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70749       };
70750     } catch (...) {
70751       {
70752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70753       };
70754     }
70755   }
70756 }
70757
70758
70759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
70760   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70761   Dali::Toolkit::ItemContainer *arg2 = 0 ;
70762   float arg3 ;
70763
70764   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70765   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
70766   if (!arg2) {
70767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
70768     return ;
70769   }
70770   arg3 = (float)jarg3;
70771   {
70772     try {
70773       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
70774     } catch (std::out_of_range& e) {
70775       {
70776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70777       };
70778     } catch (std::exception& e) {
70779       {
70780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70781       };
70782     } catch (...) {
70783       {
70784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70785       };
70786     }
70787   }
70788 }
70789
70790
70791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
70792   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70793   Dali::Toolkit::ItemId arg2 ;
70794   float arg3 ;
70795
70796   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70797   arg2 = (Dali::Toolkit::ItemId)jarg2;
70798   arg3 = (float)jarg3;
70799   {
70800     try {
70801       (arg1)->RemoveItem(arg2,arg3);
70802     } catch (std::out_of_range& e) {
70803       {
70804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70805       };
70806     } catch (std::exception& e) {
70807       {
70808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70809       };
70810     } catch (...) {
70811       {
70812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70813       };
70814     }
70815   }
70816 }
70817
70818
70819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
70820   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70821   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
70822   float arg3 ;
70823
70824   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70825   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
70826   if (!arg2) {
70827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
70828     return ;
70829   }
70830   arg3 = (float)jarg3;
70831   {
70832     try {
70833       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
70834     } catch (std::out_of_range& e) {
70835       {
70836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70837       };
70838     } catch (std::exception& e) {
70839       {
70840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70841       };
70842     } catch (...) {
70843       {
70844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70845       };
70846     }
70847   }
70848 }
70849
70850
70851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
70852   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70853   Dali::Toolkit::Item arg2 ;
70854   float arg3 ;
70855   Dali::Toolkit::Item *argp2 ;
70856
70857   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70858   argp2 = (Dali::Toolkit::Item *)jarg2;
70859   if (!argp2) {
70860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
70861     return ;
70862   }
70863   arg2 = *argp2;
70864   arg3 = (float)jarg3;
70865   {
70866     try {
70867       (arg1)->ReplaceItem(arg2,arg3);
70868     } catch (std::out_of_range& e) {
70869       {
70870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70871       };
70872     } catch (std::exception& e) {
70873       {
70874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70875       };
70876     } catch (...) {
70877       {
70878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70879       };
70880     }
70881   }
70882 }
70883
70884
70885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
70886   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70887   Dali::Toolkit::ItemContainer *arg2 = 0 ;
70888   float arg3 ;
70889
70890   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70891   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
70892   if (!arg2) {
70893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
70894     return ;
70895   }
70896   arg3 = (float)jarg3;
70897   {
70898     try {
70899       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
70900     } catch (std::out_of_range& e) {
70901       {
70902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70903       };
70904     } catch (std::exception& e) {
70905       {
70906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70907       };
70908     } catch (...) {
70909       {
70910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70911       };
70912     }
70913   }
70914 }
70915
70916
70917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
70918   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70919   Dali::Vector3 *arg2 = 0 ;
70920
70921   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70922   arg2 = (Dali::Vector3 *)jarg2;
70923   if (!arg2) {
70924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70925     return ;
70926   }
70927   {
70928     try {
70929       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
70930     } catch (std::out_of_range& e) {
70931       {
70932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70933       };
70934     } catch (std::exception& e) {
70935       {
70936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70937       };
70938     } catch (...) {
70939       {
70940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70941       };
70942     }
70943   }
70944 }
70945
70946
70947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
70948   void * jresult ;
70949   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70950   Dali::Vector3 result;
70951
70952   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70953   {
70954     try {
70955       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
70956     } catch (std::out_of_range& e) {
70957       {
70958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70959       };
70960     } catch (std::exception& e) {
70961       {
70962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70963       };
70964     } catch (...) {
70965       {
70966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70967       };
70968     }
70969   }
70970   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70971   return jresult;
70972 }
70973
70974
70975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
70976   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70977   Dali::Vector3 *arg2 = 0 ;
70978
70979   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70980   arg2 = (Dali::Vector3 *)jarg2;
70981   if (!arg2) {
70982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70983     return ;
70984   }
70985   {
70986     try {
70987       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
70988     } catch (std::out_of_range& e) {
70989       {
70990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70991       };
70992     } catch (std::exception& e) {
70993       {
70994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70995       };
70996     } catch (...) {
70997       {
70998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70999       };
71000     }
71001   }
71002 }
71003
71004
71005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
71006   void * jresult ;
71007   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71008   Dali::Vector3 result;
71009
71010   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71011   {
71012     try {
71013       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
71014     } catch (std::out_of_range& e) {
71015       {
71016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71017       };
71018     } catch (std::exception& e) {
71019       {
71020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71021       };
71022     } catch (...) {
71023       {
71024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71025       };
71026     }
71027   }
71028   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71029   return jresult;
71030 }
71031
71032
71033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
71034   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71035   Dali::Toolkit::ItemRange *arg2 = 0 ;
71036
71037   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71038   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
71039   if (!arg2) {
71040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
71041     return ;
71042   }
71043   {
71044     try {
71045       (arg1)->GetItemsRange(*arg2);
71046     } catch (std::out_of_range& e) {
71047       {
71048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71049       };
71050     } catch (std::exception& e) {
71051       {
71052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71053       };
71054     } catch (...) {
71055       {
71056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71057       };
71058     }
71059   }
71060 }
71061
71062
71063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
71064   void * jresult ;
71065   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71066   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
71067
71068   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71069   {
71070     try {
71071       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
71072     } catch (std::out_of_range& e) {
71073       {
71074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71075       };
71076     } catch (std::exception& e) {
71077       {
71078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71079       };
71080     } catch (...) {
71081       {
71082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71083       };
71084     }
71085   }
71086   jresult = (void *)result;
71087   return jresult;
71088 }
71089
71090
71091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
71092   Dali::Vector3 *arg1 = 0 ;
71093   PropertyInputContainer *arg2 = 0 ;
71094
71095   arg1 = (Dali::Vector3 *)jarg1;
71096   if (!arg1) {
71097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
71098     return ;
71099   }
71100   arg2 = (PropertyInputContainer *)jarg2;
71101   if (!arg2) {
71102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
71103     return ;
71104   }
71105   {
71106     try {
71107       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
71108     } catch (std::out_of_range& e) {
71109       {
71110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71111       };
71112     } catch (std::exception& e) {
71113       {
71114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71115       };
71116     } catch (...) {
71117       {
71118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71119       };
71120     }
71121   }
71122 }
71123
71124
71125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
71126   Dali::Vector3 *arg1 = 0 ;
71127   PropertyInputContainer *arg2 = 0 ;
71128
71129   arg1 = (Dali::Vector3 *)jarg1;
71130   if (!arg1) {
71131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
71132     return ;
71133   }
71134   arg2 = (PropertyInputContainer *)jarg2;
71135   if (!arg2) {
71136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
71137     return ;
71138   }
71139   {
71140     try {
71141       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
71142     } catch (std::out_of_range& e) {
71143       {
71144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71145       };
71146     } catch (std::exception& e) {
71147       {
71148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71149       };
71150     } catch (...) {
71151       {
71152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71153       };
71154     }
71155   }
71156 }
71157
71158
71159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
71160   void * jresult ;
71161   Dali::Toolkit::ScrollViewEffect *result = 0 ;
71162
71163   {
71164     try {
71165       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
71166     } catch (std::out_of_range& e) {
71167       {
71168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71169       };
71170     } catch (std::exception& e) {
71171       {
71172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71173       };
71174     } catch (...) {
71175       {
71176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71177       };
71178     }
71179   }
71180   jresult = (void *)result;
71181   return jresult;
71182 }
71183
71184
71185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
71186   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
71187
71188   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
71189   {
71190     try {
71191       delete arg1;
71192     } catch (std::out_of_range& e) {
71193       {
71194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71195       };
71196     } catch (std::exception& e) {
71197       {
71198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71199       };
71200     } catch (...) {
71201       {
71202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71203       };
71204     }
71205   }
71206 }
71207
71208
71209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
71210   void * jresult ;
71211   Dali::Path arg1 ;
71212   Dali::Vector3 *arg2 = 0 ;
71213   Dali::Property::Index arg3 ;
71214   Dali::Vector3 *arg4 = 0 ;
71215   unsigned int arg5 ;
71216   Dali::Path *argp1 ;
71217   Dali::Toolkit::ScrollViewPagePathEffect result;
71218
71219   argp1 = (Dali::Path *)jarg1;
71220   if (!argp1) {
71221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
71222     return 0;
71223   }
71224   arg1 = *argp1;
71225   arg2 = (Dali::Vector3 *)jarg2;
71226   if (!arg2) {
71227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71228     return 0;
71229   }
71230   arg3 = (Dali::Property::Index)jarg3;
71231   arg4 = (Dali::Vector3 *)jarg4;
71232   if (!arg4) {
71233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71234     return 0;
71235   }
71236   arg5 = (unsigned int)jarg5;
71237   {
71238     try {
71239       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
71240     } catch (std::out_of_range& e) {
71241       {
71242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71243       };
71244     } catch (std::exception& e) {
71245       {
71246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71247       };
71248     } catch (...) {
71249       {
71250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71251       };
71252     }
71253   }
71254   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
71255   return jresult;
71256 }
71257
71258
71259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
71260   void * jresult ;
71261   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
71262
71263   {
71264     try {
71265       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
71266     } catch (std::out_of_range& e) {
71267       {
71268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71269       };
71270     } catch (std::exception& e) {
71271       {
71272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71273       };
71274     } catch (...) {
71275       {
71276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71277       };
71278     }
71279   }
71280   jresult = (void *)result;
71281   return jresult;
71282 }
71283
71284
71285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
71286   void * jresult ;
71287   Dali::BaseHandle arg1 ;
71288   Dali::BaseHandle *argp1 ;
71289   Dali::Toolkit::ScrollViewPagePathEffect result;
71290
71291   argp1 = (Dali::BaseHandle *)jarg1;
71292   if (!argp1) {
71293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71294     return 0;
71295   }
71296   arg1 = *argp1;
71297   {
71298     try {
71299       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
71300     } catch (std::out_of_range& e) {
71301       {
71302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71303       };
71304     } catch (std::exception& e) {
71305       {
71306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71307       };
71308     } catch (...) {
71309       {
71310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71311       };
71312     }
71313   }
71314   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
71315   return jresult;
71316 }
71317
71318
71319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
71320   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
71321   Dali::Actor arg2 ;
71322   unsigned int arg3 ;
71323   Dali::Actor *argp2 ;
71324
71325   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
71326   argp2 = (Dali::Actor *)jarg2;
71327   if (!argp2) {
71328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71329     return ;
71330   }
71331   arg2 = *argp2;
71332   arg3 = (unsigned int)jarg3;
71333   {
71334     try {
71335       (arg1)->ApplyToPage(arg2,arg3);
71336     } catch (std::out_of_range& e) {
71337       {
71338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71339       };
71340     } catch (std::exception& e) {
71341       {
71342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71343       };
71344     } catch (...) {
71345       {
71346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71347       };
71348     }
71349   }
71350 }
71351
71352
71353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
71354   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
71355
71356   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
71357   {
71358     try {
71359       delete arg1;
71360     } catch (std::out_of_range& e) {
71361       {
71362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71363       };
71364     } catch (std::exception& e) {
71365       {
71366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71367       };
71368     } catch (...) {
71369       {
71370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71371       };
71372     }
71373   }
71374 }
71375
71376
71377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
71378   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71379   Dali::Toolkit::ClampState arg2 ;
71380
71381   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71382   arg2 = (Dali::Toolkit::ClampState)jarg2;
71383   if (arg1) (arg1)->x = arg2;
71384 }
71385
71386
71387 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
71388   int jresult ;
71389   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71390   Dali::Toolkit::ClampState result;
71391
71392   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71393   result = (Dali::Toolkit::ClampState) ((arg1)->x);
71394   jresult = (int)result;
71395   return jresult;
71396 }
71397
71398
71399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
71400   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71401   Dali::Toolkit::ClampState arg2 ;
71402
71403   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71404   arg2 = (Dali::Toolkit::ClampState)jarg2;
71405   if (arg1) (arg1)->y = arg2;
71406 }
71407
71408
71409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
71410   int jresult ;
71411   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71412   Dali::Toolkit::ClampState result;
71413
71414   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71415   result = (Dali::Toolkit::ClampState) ((arg1)->y);
71416   jresult = (int)result;
71417   return jresult;
71418 }
71419
71420
71421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
71422   void * jresult ;
71423   Dali::Toolkit::ClampState2D *result = 0 ;
71424
71425   {
71426     try {
71427       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
71428     } catch (std::out_of_range& e) {
71429       {
71430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71431       };
71432     } catch (std::exception& e) {
71433       {
71434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71435       };
71436     } catch (...) {
71437       {
71438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71439       };
71440     }
71441   }
71442   jresult = (void *)result;
71443   return jresult;
71444 }
71445
71446
71447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
71448   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71449
71450   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71451   {
71452     try {
71453       delete arg1;
71454     } catch (std::out_of_range& e) {
71455       {
71456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71457       };
71458     } catch (std::exception& e) {
71459       {
71460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71461       };
71462     } catch (...) {
71463       {
71464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71465       };
71466     }
71467   }
71468 }
71469
71470
71471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
71472   void * jresult ;
71473   float arg1 ;
71474   float arg2 ;
71475   bool arg3 ;
71476   Dali::Toolkit::RulerDomain *result = 0 ;
71477
71478   arg1 = (float)jarg1;
71479   arg2 = (float)jarg2;
71480   arg3 = jarg3 ? true : false;
71481   {
71482     try {
71483       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
71484     } catch (std::out_of_range& e) {
71485       {
71486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71487       };
71488     } catch (std::exception& e) {
71489       {
71490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71491       };
71492     } catch (...) {
71493       {
71494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71495       };
71496     }
71497   }
71498   jresult = (void *)result;
71499   return jresult;
71500 }
71501
71502
71503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
71504   void * jresult ;
71505   float arg1 ;
71506   float arg2 ;
71507   Dali::Toolkit::RulerDomain *result = 0 ;
71508
71509   arg1 = (float)jarg1;
71510   arg2 = (float)jarg2;
71511   {
71512     try {
71513       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
71514     } catch (std::out_of_range& e) {
71515       {
71516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71517       };
71518     } catch (std::exception& e) {
71519       {
71520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71521       };
71522     } catch (...) {
71523       {
71524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71525       };
71526     }
71527   }
71528   jresult = (void *)result;
71529   return jresult;
71530 }
71531
71532
71533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
71534   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71535   float arg2 ;
71536
71537   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71538   arg2 = (float)jarg2;
71539   if (arg1) (arg1)->min = arg2;
71540 }
71541
71542
71543 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
71544   float jresult ;
71545   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71546   float result;
71547
71548   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71549   result = (float) ((arg1)->min);
71550   jresult = result;
71551   return jresult;
71552 }
71553
71554
71555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
71556   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71557   float arg2 ;
71558
71559   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71560   arg2 = (float)jarg2;
71561   if (arg1) (arg1)->max = arg2;
71562 }
71563
71564
71565 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
71566   float jresult ;
71567   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71568   float result;
71569
71570   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71571   result = (float) ((arg1)->max);
71572   jresult = result;
71573   return jresult;
71574 }
71575
71576
71577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
71578   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71579   bool arg2 ;
71580
71581   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71582   arg2 = jarg2 ? true : false;
71583   if (arg1) (arg1)->enabled = arg2;
71584 }
71585
71586
71587 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
71588   unsigned int jresult ;
71589   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71590   bool result;
71591
71592   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71593   result = (bool) ((arg1)->enabled);
71594   jresult = result;
71595   return jresult;
71596 }
71597
71598
71599 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
71600   float jresult ;
71601   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71602   float arg2 ;
71603   float arg3 ;
71604   float arg4 ;
71605   float result;
71606
71607   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71608   arg2 = (float)jarg2;
71609   arg3 = (float)jarg3;
71610   arg4 = (float)jarg4;
71611   {
71612     try {
71613       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
71614     } catch (std::out_of_range& e) {
71615       {
71616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71617       };
71618     } catch (std::exception& e) {
71619       {
71620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71621       };
71622     } catch (...) {
71623       {
71624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71625       };
71626     }
71627   }
71628   jresult = result;
71629   return jresult;
71630 }
71631
71632
71633 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
71634   float jresult ;
71635   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71636   float arg2 ;
71637   float arg3 ;
71638   float result;
71639
71640   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71641   arg2 = (float)jarg2;
71642   arg3 = (float)jarg3;
71643   {
71644     try {
71645       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
71646     } catch (std::out_of_range& e) {
71647       {
71648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71649       };
71650     } catch (std::exception& e) {
71651       {
71652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71653       };
71654     } catch (...) {
71655       {
71656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71657       };
71658     }
71659   }
71660   jresult = result;
71661   return jresult;
71662 }
71663
71664
71665 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
71666   float jresult ;
71667   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71668   float arg2 ;
71669   float result;
71670
71671   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71672   arg2 = (float)jarg2;
71673   {
71674     try {
71675       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
71676     } catch (std::out_of_range& e) {
71677       {
71678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71679       };
71680     } catch (std::exception& e) {
71681       {
71682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71683       };
71684     } catch (...) {
71685       {
71686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71687       };
71688     }
71689   }
71690   jresult = result;
71691   return jresult;
71692 }
71693
71694
71695 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
71696   float jresult ;
71697   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71698   float arg2 ;
71699   float arg3 ;
71700   float arg4 ;
71701   Dali::Toolkit::ClampState *arg5 = 0 ;
71702   float result;
71703
71704   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71705   arg2 = (float)jarg2;
71706   arg3 = (float)jarg3;
71707   arg4 = (float)jarg4;
71708   arg5 = (Dali::Toolkit::ClampState *)jarg5;
71709   if (!arg5) {
71710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
71711     return 0;
71712   }
71713   {
71714     try {
71715       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
71716     } catch (std::out_of_range& e) {
71717       {
71718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71719       };
71720     } catch (std::exception& e) {
71721       {
71722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71723       };
71724     } catch (...) {
71725       {
71726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71727       };
71728     }
71729   }
71730   jresult = result;
71731   return jresult;
71732 }
71733
71734
71735 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
71736   float jresult ;
71737   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71738   float result;
71739
71740   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71741   {
71742     try {
71743       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
71744     } catch (std::out_of_range& e) {
71745       {
71746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71747       };
71748     } catch (std::exception& e) {
71749       {
71750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71751       };
71752     } catch (...) {
71753       {
71754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71755       };
71756     }
71757   }
71758   jresult = result;
71759   return jresult;
71760 }
71761
71762
71763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
71764   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71765
71766   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71767   {
71768     try {
71769       delete arg1;
71770     } catch (std::out_of_range& e) {
71771       {
71772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71773       };
71774     } catch (std::exception& e) {
71775       {
71776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71777       };
71778     } catch (...) {
71779       {
71780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71781       };
71782     }
71783   }
71784 }
71785
71786
71787 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
71788   float jresult ;
71789   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71790   float arg2 ;
71791   float arg3 ;
71792   float result;
71793
71794   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71795   arg2 = (float)jarg2;
71796   arg3 = (float)jarg3;
71797   {
71798     try {
71799       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
71800     } catch (std::out_of_range& e) {
71801       {
71802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71803       };
71804     } catch (std::exception& e) {
71805       {
71806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71807       };
71808     } catch (...) {
71809       {
71810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71811       };
71812     }
71813   }
71814   jresult = result;
71815   return jresult;
71816 }
71817
71818
71819 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
71820   float jresult ;
71821   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71822   float arg2 ;
71823   float result;
71824
71825   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71826   arg2 = (float)jarg2;
71827   {
71828     try {
71829       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
71830     } catch (std::out_of_range& e) {
71831       {
71832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71833       };
71834     } catch (std::exception& e) {
71835       {
71836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71837       };
71838     } catch (...) {
71839       {
71840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71841       };
71842     }
71843   }
71844   jresult = result;
71845   return jresult;
71846 }
71847
71848
71849 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
71850   float jresult ;
71851   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71852   unsigned int arg2 ;
71853   unsigned int *arg3 = 0 ;
71854   bool arg4 ;
71855   float result;
71856
71857   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71858   arg2 = (unsigned int)jarg2;
71859   arg3 = (unsigned int *)jarg3;
71860   arg4 = jarg4 ? true : false;
71861   {
71862     try {
71863       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
71864     } catch (std::out_of_range& e) {
71865       {
71866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71867       };
71868     } catch (std::exception& e) {
71869       {
71870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71871       };
71872     } catch (...) {
71873       {
71874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71875       };
71876     }
71877   }
71878   jresult = result;
71879   return jresult;
71880 }
71881
71882
71883 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
71884   unsigned int jresult ;
71885   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71886   float arg2 ;
71887   bool arg3 ;
71888   unsigned int result;
71889
71890   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71891   arg2 = (float)jarg2;
71892   arg3 = jarg3 ? true : false;
71893   {
71894     try {
71895       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
71896     } catch (std::out_of_range& e) {
71897       {
71898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71899       };
71900     } catch (std::exception& e) {
71901       {
71902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71903       };
71904     } catch (...) {
71905       {
71906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71907       };
71908     }
71909   }
71910   jresult = result;
71911   return jresult;
71912 }
71913
71914
71915 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
71916   unsigned int jresult ;
71917   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71918   unsigned int result;
71919
71920   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71921   {
71922     try {
71923       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
71924     } catch (std::out_of_range& e) {
71925       {
71926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71927       };
71928     } catch (std::exception& e) {
71929       {
71930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71931       };
71932     } catch (...) {
71933       {
71934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71935       };
71936     }
71937   }
71938   jresult = result;
71939   return jresult;
71940 }
71941
71942
71943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
71944   int jresult ;
71945   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71946   Dali::Toolkit::Ruler::RulerType result;
71947
71948   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71949   {
71950     try {
71951       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
71952     } catch (std::out_of_range& e) {
71953       {
71954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71955       };
71956     } catch (std::exception& e) {
71957       {
71958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71959       };
71960     } catch (...) {
71961       {
71962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71963       };
71964     }
71965   }
71966   jresult = (int)result;
71967   return jresult;
71968 }
71969
71970
71971 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
71972   unsigned int jresult ;
71973   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71974   bool result;
71975
71976   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71977   {
71978     try {
71979       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
71980     } catch (std::out_of_range& e) {
71981       {
71982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71983       };
71984     } catch (std::exception& e) {
71985       {
71986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71987       };
71988     } catch (...) {
71989       {
71990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71991       };
71992     }
71993   }
71994   jresult = result;
71995   return jresult;
71996 }
71997
71998
71999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
72000   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72001
72002   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72003   {
72004     try {
72005       (arg1)->Enable();
72006     } catch (std::out_of_range& e) {
72007       {
72008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72009       };
72010     } catch (std::exception& e) {
72011       {
72012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72013       };
72014     } catch (...) {
72015       {
72016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72017       };
72018     }
72019   }
72020 }
72021
72022
72023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
72024   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72025
72026   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72027   {
72028     try {
72029       (arg1)->Disable();
72030     } catch (std::out_of_range& e) {
72031       {
72032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72033       };
72034     } catch (std::exception& e) {
72035       {
72036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72037       };
72038     } catch (...) {
72039       {
72040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72041       };
72042     }
72043   }
72044 }
72045
72046
72047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
72048   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72049   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
72050   Dali::Toolkit::RulerDomain *argp2 ;
72051
72052   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72053   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
72054   if (!argp2) {
72055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
72056     return ;
72057   }
72058   arg2 = *argp2;
72059   {
72060     try {
72061       (arg1)->SetDomain(arg2);
72062     } catch (std::out_of_range& e) {
72063       {
72064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72065       };
72066     } catch (std::exception& e) {
72067       {
72068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72069       };
72070     } catch (...) {
72071       {
72072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72073       };
72074     }
72075   }
72076 }
72077
72078
72079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
72080   void * jresult ;
72081   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72082   Dali::Toolkit::RulerDomain *result = 0 ;
72083
72084   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72085   {
72086     try {
72087       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
72088     } catch (std::out_of_range& e) {
72089       {
72090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72091       };
72092     } catch (std::exception& e) {
72093       {
72094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72095       };
72096     } catch (...) {
72097       {
72098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72099       };
72100     }
72101   }
72102   jresult = (void *)result;
72103   return jresult;
72104 }
72105
72106
72107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
72108   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72109
72110   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72111   {
72112     try {
72113       (arg1)->DisableDomain();
72114     } catch (std::out_of_range& e) {
72115       {
72116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72117       };
72118     } catch (std::exception& e) {
72119       {
72120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72121       };
72122     } catch (...) {
72123       {
72124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72125       };
72126     }
72127   }
72128 }
72129
72130
72131 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
72132   float jresult ;
72133   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72134   float arg2 ;
72135   float arg3 ;
72136   float arg4 ;
72137   float result;
72138
72139   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72140   arg2 = (float)jarg2;
72141   arg3 = (float)jarg3;
72142   arg4 = (float)jarg4;
72143   {
72144     try {
72145       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
72146     } catch (std::out_of_range& e) {
72147       {
72148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72149       };
72150     } catch (std::exception& e) {
72151       {
72152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72153       };
72154     } catch (...) {
72155       {
72156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72157       };
72158     }
72159   }
72160   jresult = result;
72161   return jresult;
72162 }
72163
72164
72165 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
72166   float jresult ;
72167   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72168   float arg2 ;
72169   float arg3 ;
72170   float result;
72171
72172   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72173   arg2 = (float)jarg2;
72174   arg3 = (float)jarg3;
72175   {
72176     try {
72177       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
72178     } catch (std::out_of_range& e) {
72179       {
72180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72181       };
72182     } catch (std::exception& e) {
72183       {
72184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72185       };
72186     } catch (...) {
72187       {
72188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72189       };
72190     }
72191   }
72192   jresult = result;
72193   return jresult;
72194 }
72195
72196
72197 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
72198   float jresult ;
72199   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72200   float arg2 ;
72201   float result;
72202
72203   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72204   arg2 = (float)jarg2;
72205   {
72206     try {
72207       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
72208     } catch (std::out_of_range& e) {
72209       {
72210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72211       };
72212     } catch (std::exception& e) {
72213       {
72214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72215       };
72216     } catch (...) {
72217       {
72218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72219       };
72220     }
72221   }
72222   jresult = result;
72223   return jresult;
72224 }
72225
72226
72227 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
72228   float jresult ;
72229   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72230   float arg2 ;
72231   float arg3 ;
72232   float arg4 ;
72233   Dali::Toolkit::ClampState *arg5 = 0 ;
72234   float result;
72235
72236   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72237   arg2 = (float)jarg2;
72238   arg3 = (float)jarg3;
72239   arg4 = (float)jarg4;
72240   arg5 = (Dali::Toolkit::ClampState *)jarg5;
72241   if (!arg5) {
72242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72243     return 0;
72244   }
72245   {
72246     try {
72247       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
72248     } catch (std::out_of_range& e) {
72249       {
72250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72251       };
72252     } catch (std::exception& e) {
72253       {
72254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72255       };
72256     } catch (...) {
72257       {
72258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72259       };
72260     }
72261   }
72262   jresult = result;
72263   return jresult;
72264 }
72265
72266
72267 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
72268   float jresult ;
72269   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72270   float arg2 ;
72271   float arg3 ;
72272   float arg4 ;
72273   float arg5 ;
72274   float result;
72275
72276   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72277   arg2 = (float)jarg2;
72278   arg3 = (float)jarg3;
72279   arg4 = (float)jarg4;
72280   arg5 = (float)jarg5;
72281   {
72282     try {
72283       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
72284     } catch (std::out_of_range& e) {
72285       {
72286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72287       };
72288     } catch (std::exception& e) {
72289       {
72290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72291       };
72292     } catch (...) {
72293       {
72294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72295       };
72296     }
72297   }
72298   jresult = result;
72299   return jresult;
72300 }
72301
72302
72303 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
72304   float jresult ;
72305   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72306   float arg2 ;
72307   float arg3 ;
72308   float arg4 ;
72309   float result;
72310
72311   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72312   arg2 = (float)jarg2;
72313   arg3 = (float)jarg3;
72314   arg4 = (float)jarg4;
72315   {
72316     try {
72317       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
72318     } catch (std::out_of_range& e) {
72319       {
72320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72321       };
72322     } catch (std::exception& e) {
72323       {
72324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72325       };
72326     } catch (...) {
72327       {
72328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72329       };
72330     }
72331   }
72332   jresult = result;
72333   return jresult;
72334 }
72335
72336
72337 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
72338   float jresult ;
72339   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72340   float arg2 ;
72341   float arg3 ;
72342   float result;
72343
72344   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72345   arg2 = (float)jarg2;
72346   arg3 = (float)jarg3;
72347   {
72348     try {
72349       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
72350     } catch (std::out_of_range& e) {
72351       {
72352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72353       };
72354     } catch (std::exception& e) {
72355       {
72356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72357       };
72358     } catch (...) {
72359       {
72360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72361       };
72362     }
72363   }
72364   jresult = result;
72365   return jresult;
72366 }
72367
72368
72369 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
72370   float jresult ;
72371   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72372   float arg2 ;
72373   float result;
72374
72375   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72376   arg2 = (float)jarg2;
72377   {
72378     try {
72379       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
72380     } catch (std::out_of_range& e) {
72381       {
72382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72383       };
72384     } catch (std::exception& e) {
72385       {
72386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72387       };
72388     } catch (...) {
72389       {
72390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72391       };
72392     }
72393   }
72394   jresult = result;
72395   return jresult;
72396 }
72397
72398
72399 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
72400   float jresult ;
72401   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72402   float arg2 ;
72403   float arg3 ;
72404   float arg4 ;
72405   float arg5 ;
72406   Dali::Toolkit::ClampState *arg6 = 0 ;
72407   float result;
72408
72409   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72410   arg2 = (float)jarg2;
72411   arg3 = (float)jarg3;
72412   arg4 = (float)jarg4;
72413   arg5 = (float)jarg5;
72414   arg6 = (Dali::Toolkit::ClampState *)jarg6;
72415   if (!arg6) {
72416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72417     return 0;
72418   }
72419   {
72420     try {
72421       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
72422     } catch (std::out_of_range& e) {
72423       {
72424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72425       };
72426     } catch (std::exception& e) {
72427       {
72428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72429       };
72430     } catch (...) {
72431       {
72432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72433       };
72434     }
72435   }
72436   jresult = result;
72437   return jresult;
72438 }
72439
72440
72441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
72442   void * jresult ;
72443   Dali::Toolkit::DefaultRuler *result = 0 ;
72444
72445   {
72446     try {
72447       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
72448     } catch (std::out_of_range& e) {
72449       {
72450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72451       };
72452     } catch (std::exception& e) {
72453       {
72454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72455       };
72456     } catch (...) {
72457       {
72458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72459       };
72460     }
72461   }
72462   jresult = (void *)result;
72463   return jresult;
72464 }
72465
72466
72467 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
72468   float jresult ;
72469   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72470   float arg2 ;
72471   float arg3 ;
72472   float result;
72473
72474   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72475   arg2 = (float)jarg2;
72476   arg3 = (float)jarg3;
72477   {
72478     try {
72479       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
72480     } catch (std::out_of_range& e) {
72481       {
72482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72483       };
72484     } catch (std::exception& e) {
72485       {
72486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72487       };
72488     } catch (...) {
72489       {
72490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72491       };
72492     }
72493   }
72494   jresult = result;
72495   return jresult;
72496 }
72497
72498
72499 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72500   float jresult ;
72501   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72502   unsigned int arg2 ;
72503   unsigned int *arg3 = 0 ;
72504   bool arg4 ;
72505   float result;
72506
72507   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72508   arg2 = (unsigned int)jarg2;
72509   arg3 = (unsigned int *)jarg3;
72510   arg4 = jarg4 ? true : false;
72511   {
72512     try {
72513       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72514     } catch (std::out_of_range& e) {
72515       {
72516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72517       };
72518     } catch (std::exception& e) {
72519       {
72520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72521       };
72522     } catch (...) {
72523       {
72524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72525       };
72526     }
72527   }
72528   jresult = result;
72529   return jresult;
72530 }
72531
72532
72533 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72534   unsigned int jresult ;
72535   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72536   float arg2 ;
72537   bool arg3 ;
72538   unsigned int result;
72539
72540   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72541   arg2 = (float)jarg2;
72542   arg3 = jarg3 ? true : false;
72543   {
72544     try {
72545       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
72546     } catch (std::out_of_range& e) {
72547       {
72548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72549       };
72550     } catch (std::exception& e) {
72551       {
72552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72553       };
72554     } catch (...) {
72555       {
72556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72557       };
72558     }
72559   }
72560   jresult = result;
72561   return jresult;
72562 }
72563
72564
72565 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
72566   unsigned int jresult ;
72567   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72568   unsigned int result;
72569
72570   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72571   {
72572     try {
72573       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
72574     } catch (std::out_of_range& e) {
72575       {
72576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72577       };
72578     } catch (std::exception& e) {
72579       {
72580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72581       };
72582     } catch (...) {
72583       {
72584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72585       };
72586     }
72587   }
72588   jresult = result;
72589   return jresult;
72590 }
72591
72592
72593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
72594   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72595
72596   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72597   {
72598     try {
72599       delete arg1;
72600     } catch (std::out_of_range& e) {
72601       {
72602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72603       };
72604     } catch (std::exception& e) {
72605       {
72606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72607       };
72608     } catch (...) {
72609       {
72610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72611       };
72612     }
72613   }
72614 }
72615
72616
72617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
72618   void * jresult ;
72619   float arg1 ;
72620   Dali::Toolkit::FixedRuler *result = 0 ;
72621
72622   arg1 = (float)jarg1;
72623   {
72624     try {
72625       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
72626     } catch (std::out_of_range& e) {
72627       {
72628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72629       };
72630     } catch (std::exception& e) {
72631       {
72632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72633       };
72634     } catch (...) {
72635       {
72636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72637       };
72638     }
72639   }
72640   jresult = (void *)result;
72641   return jresult;
72642 }
72643
72644
72645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
72646   void * jresult ;
72647   Dali::Toolkit::FixedRuler *result = 0 ;
72648
72649   {
72650     try {
72651       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
72652     } catch (std::out_of_range& e) {
72653       {
72654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72655       };
72656     } catch (std::exception& e) {
72657       {
72658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72659       };
72660     } catch (...) {
72661       {
72662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72663       };
72664     }
72665   }
72666   jresult = (void *)result;
72667   return jresult;
72668 }
72669
72670
72671 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
72672   float jresult ;
72673   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72674   float arg2 ;
72675   float arg3 ;
72676   float result;
72677
72678   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72679   arg2 = (float)jarg2;
72680   arg3 = (float)jarg3;
72681   {
72682     try {
72683       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
72684     } catch (std::out_of_range& e) {
72685       {
72686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72687       };
72688     } catch (std::exception& e) {
72689       {
72690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72691       };
72692     } catch (...) {
72693       {
72694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72695       };
72696     }
72697   }
72698   jresult = result;
72699   return jresult;
72700 }
72701
72702
72703 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72704   float jresult ;
72705   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72706   unsigned int arg2 ;
72707   unsigned int *arg3 = 0 ;
72708   bool arg4 ;
72709   float result;
72710
72711   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72712   arg2 = (unsigned int)jarg2;
72713   arg3 = (unsigned int *)jarg3;
72714   arg4 = jarg4 ? true : false;
72715   {
72716     try {
72717       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72718     } catch (std::out_of_range& e) {
72719       {
72720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72721       };
72722     } catch (std::exception& e) {
72723       {
72724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72725       };
72726     } catch (...) {
72727       {
72728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72729       };
72730     }
72731   }
72732   jresult = result;
72733   return jresult;
72734 }
72735
72736
72737 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72738   unsigned int jresult ;
72739   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72740   float arg2 ;
72741   bool arg3 ;
72742   unsigned int result;
72743
72744   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72745   arg2 = (float)jarg2;
72746   arg3 = jarg3 ? true : false;
72747   {
72748     try {
72749       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
72750     } catch (std::out_of_range& e) {
72751       {
72752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72753       };
72754     } catch (std::exception& e) {
72755       {
72756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72757       };
72758     } catch (...) {
72759       {
72760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72761       };
72762     }
72763   }
72764   jresult = result;
72765   return jresult;
72766 }
72767
72768
72769 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
72770   unsigned int jresult ;
72771   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72772   unsigned int result;
72773
72774   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72775   {
72776     try {
72777       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
72778     } catch (std::out_of_range& e) {
72779       {
72780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72781       };
72782     } catch (std::exception& e) {
72783       {
72784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72785       };
72786     } catch (...) {
72787       {
72788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72789       };
72790     }
72791   }
72792   jresult = result;
72793   return jresult;
72794 }
72795
72796
72797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
72798   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72799
72800   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72801   {
72802     try {
72803       delete arg1;
72804     } catch (std::out_of_range& e) {
72805       {
72806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72807       };
72808     } catch (std::exception& e) {
72809       {
72810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72811       };
72812     } catch (...) {
72813       {
72814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72815       };
72816     }
72817   }
72818 }
72819
72820
72821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
72822   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72823   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
72824
72825   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72826   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
72827   if (arg1) (arg1)->scale = *arg2;
72828 }
72829
72830
72831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
72832   void * jresult ;
72833   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72834   Dali::Toolkit::ClampState2D *result = 0 ;
72835
72836   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72837   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
72838   jresult = (void *)result;
72839   return jresult;
72840 }
72841
72842
72843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
72844   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72845   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
72846
72847   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72848   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
72849   if (arg1) (arg1)->position = *arg2;
72850 }
72851
72852
72853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
72854   void * jresult ;
72855   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72856   Dali::Toolkit::ClampState2D *result = 0 ;
72857
72858   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72859   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
72860   jresult = (void *)result;
72861   return jresult;
72862 }
72863
72864
72865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
72866   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72867   Dali::Toolkit::ClampState arg2 ;
72868
72869   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72870   arg2 = (Dali::Toolkit::ClampState)jarg2;
72871   if (arg1) (arg1)->rotation = arg2;
72872 }
72873
72874
72875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
72876   int jresult ;
72877   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72878   Dali::Toolkit::ClampState result;
72879
72880   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72881   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
72882   jresult = (int)result;
72883   return jresult;
72884 }
72885
72886
72887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
72888   void * jresult ;
72889   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
72890
72891   {
72892     try {
72893       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
72894     } catch (std::out_of_range& e) {
72895       {
72896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72897       };
72898     } catch (std::exception& e) {
72899       {
72900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72901       };
72902     } catch (...) {
72903       {
72904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72905       };
72906     }
72907   }
72908   jresult = (void *)result;
72909   return jresult;
72910 }
72911
72912
72913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
72914   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72915
72916   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72917   {
72918     try {
72919       delete arg1;
72920     } catch (std::out_of_range& e) {
72921       {
72922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72923       };
72924     } catch (std::exception& e) {
72925       {
72926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72927       };
72928     } catch (...) {
72929       {
72930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72931       };
72932     }
72933   }
72934 }
72935
72936
72937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
72938   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72939   Dali::Toolkit::SnapType arg2 ;
72940
72941   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72942   arg2 = (Dali::Toolkit::SnapType)jarg2;
72943   if (arg1) (arg1)->type = arg2;
72944 }
72945
72946
72947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
72948   int jresult ;
72949   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72950   Dali::Toolkit::SnapType result;
72951
72952   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72953   result = (Dali::Toolkit::SnapType) ((arg1)->type);
72954   jresult = (int)result;
72955   return jresult;
72956 }
72957
72958
72959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
72960   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72961   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
72962
72963   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72964   arg2 = (Dali::Vector2 *)jarg2;
72965   if (arg1) (arg1)->position = *arg2;
72966 }
72967
72968
72969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
72970   void * jresult ;
72971   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72972   Dali::Vector2 *result = 0 ;
72973
72974   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72975   result = (Dali::Vector2 *)& ((arg1)->position);
72976   jresult = (void *)result;
72977   return jresult;
72978 }
72979
72980
72981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
72982   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72983   float arg2 ;
72984
72985   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72986   arg2 = (float)jarg2;
72987   if (arg1) (arg1)->duration = arg2;
72988 }
72989
72990
72991 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
72992   float jresult ;
72993   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72994   float result;
72995
72996   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72997   result = (float) ((arg1)->duration);
72998   jresult = result;
72999   return jresult;
73000 }
73001
73002
73003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
73004   void * jresult ;
73005   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
73006
73007   {
73008     try {
73009       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
73010     } catch (std::out_of_range& e) {
73011       {
73012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73013       };
73014     } catch (std::exception& e) {
73015       {
73016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73017       };
73018     } catch (...) {
73019       {
73020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73021       };
73022     }
73023   }
73024   jresult = (void *)result;
73025   return jresult;
73026 }
73027
73028
73029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
73030   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73031
73032   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73033   {
73034     try {
73035       delete arg1;
73036     } catch (std::out_of_range& e) {
73037       {
73038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73039       };
73040     } catch (std::exception& e) {
73041       {
73042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73043       };
73044     } catch (...) {
73045       {
73046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73047       };
73048     }
73049   }
73050 }
73051
73052
73053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
73054   int jresult ;
73055   int result;
73056
73057   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
73058   jresult = (int)result;
73059   return jresult;
73060 }
73061
73062
73063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
73064   int jresult ;
73065   int result;
73066
73067   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
73068   jresult = (int)result;
73069   return jresult;
73070 }
73071
73072
73073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
73074   int jresult ;
73075   int result;
73076
73077   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
73078   jresult = (int)result;
73079   return jresult;
73080 }
73081
73082
73083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
73084   int jresult ;
73085   int result;
73086
73087   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
73088   jresult = (int)result;
73089   return jresult;
73090 }
73091
73092
73093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
73094   int jresult ;
73095   int result;
73096
73097   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
73098   jresult = (int)result;
73099   return jresult;
73100 }
73101
73102
73103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
73104   int jresult ;
73105   int result;
73106
73107   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
73108   jresult = (int)result;
73109   return jresult;
73110 }
73111
73112
73113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
73114   int jresult ;
73115   int result;
73116
73117   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
73118   jresult = (int)result;
73119   return jresult;
73120 }
73121
73122
73123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
73124   int jresult ;
73125   int result;
73126
73127   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
73128   jresult = (int)result;
73129   return jresult;
73130 }
73131
73132
73133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
73134   int jresult ;
73135   int result;
73136
73137   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
73138   jresult = (int)result;
73139   return jresult;
73140 }
73141
73142
73143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
73144   int jresult ;
73145   int result;
73146
73147   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
73148   jresult = (int)result;
73149   return jresult;
73150 }
73151
73152
73153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
73154   int jresult ;
73155   int result;
73156
73157   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
73158   jresult = (int)result;
73159   return jresult;
73160 }
73161
73162
73163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
73164   int jresult ;
73165   int result;
73166
73167   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
73168   jresult = (int)result;
73169   return jresult;
73170 }
73171
73172
73173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
73174   int jresult ;
73175   int result;
73176
73177   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
73178   jresult = (int)result;
73179   return jresult;
73180 }
73181
73182
73183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
73184   int jresult ;
73185   int result;
73186
73187   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
73188   jresult = (int)result;
73189   return jresult;
73190 }
73191
73192
73193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
73194   int jresult ;
73195   int result;
73196
73197   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
73198   jresult = (int)result;
73199   return jresult;
73200 }
73201
73202
73203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
73204   int jresult ;
73205   int result;
73206
73207   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
73208   jresult = (int)result;
73209   return jresult;
73210 }
73211
73212
73213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
73214   int jresult ;
73215   int result;
73216
73217   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
73218   jresult = (int)result;
73219   return jresult;
73220 }
73221
73222
73223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
73224   int jresult ;
73225   int result;
73226
73227   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
73228   jresult = (int)result;
73229   return jresult;
73230 }
73231
73232
73233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
73234   int jresult ;
73235   int result;
73236
73237   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
73238   jresult = (int)result;
73239   return jresult;
73240 }
73241
73242
73243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
73244   int jresult ;
73245   int result;
73246
73247   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
73248   jresult = (int)result;
73249   return jresult;
73250 }
73251
73252
73253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
73254   int jresult ;
73255   int result;
73256
73257   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
73258   jresult = (int)result;
73259   return jresult;
73260 }
73261
73262
73263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
73264   int jresult ;
73265   int result;
73266
73267   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
73268   jresult = (int)result;
73269   return jresult;
73270 }
73271
73272
73273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
73274   int jresult ;
73275   int result;
73276
73277   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
73278   jresult = (int)result;
73279   return jresult;
73280 }
73281
73282
73283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
73284   int jresult ;
73285   int result;
73286
73287   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
73288   jresult = (int)result;
73289   return jresult;
73290 }
73291
73292
73293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
73294   int jresult ;
73295   int result;
73296
73297   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
73298   jresult = (int)result;
73299   return jresult;
73300 }
73301
73302
73303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
73304   void * jresult ;
73305   Dali::Toolkit::ScrollView::Property *result = 0 ;
73306
73307   {
73308     try {
73309       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
73310     } catch (std::out_of_range& e) {
73311       {
73312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73313       };
73314     } catch (std::exception& e) {
73315       {
73316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73317       };
73318     } catch (...) {
73319       {
73320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73321       };
73322     }
73323   }
73324   jresult = (void *)result;
73325   return jresult;
73326 }
73327
73328
73329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
73330   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
73331
73332   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
73333   {
73334     try {
73335       delete arg1;
73336     } catch (std::out_of_range& e) {
73337       {
73338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73339       };
73340     } catch (std::exception& e) {
73341       {
73342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73343       };
73344     } catch (...) {
73345       {
73346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73347       };
73348     }
73349   }
73350 }
73351
73352
73353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
73354   void * jresult ;
73355   Dali::Toolkit::ScrollView *result = 0 ;
73356
73357   {
73358     try {
73359       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
73360     } catch (std::out_of_range& e) {
73361       {
73362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73363       };
73364     } catch (std::exception& e) {
73365       {
73366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73367       };
73368     } catch (...) {
73369       {
73370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73371       };
73372     }
73373   }
73374   jresult = (void *)result;
73375   return jresult;
73376 }
73377
73378
73379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
73380   void * jresult ;
73381   Dali::Toolkit::ScrollView *arg1 = 0 ;
73382   Dali::Toolkit::ScrollView *result = 0 ;
73383
73384   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73385   if (!arg1) {
73386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
73387     return 0;
73388   }
73389   {
73390     try {
73391       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
73392     } catch (std::out_of_range& e) {
73393       {
73394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73395       };
73396     } catch (std::exception& e) {
73397       {
73398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73399       };
73400     } catch (...) {
73401       {
73402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73403       };
73404     }
73405   }
73406   jresult = (void *)result;
73407   return jresult;
73408 }
73409
73410
73411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
73412   void * jresult ;
73413   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73414   Dali::Toolkit::ScrollView *arg2 = 0 ;
73415   Dali::Toolkit::ScrollView *result = 0 ;
73416
73417   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73418   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
73419   if (!arg2) {
73420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
73421     return 0;
73422   }
73423   {
73424     try {
73425       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
73426     } catch (std::out_of_range& e) {
73427       {
73428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73429       };
73430     } catch (std::exception& e) {
73431       {
73432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73433       };
73434     } catch (...) {
73435       {
73436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73437       };
73438     }
73439   }
73440   jresult = (void *)result;
73441   return jresult;
73442 }
73443
73444
73445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
73446   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73447
73448   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73449   {
73450     try {
73451       delete arg1;
73452     } catch (std::out_of_range& e) {
73453       {
73454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73455       };
73456     } catch (std::exception& e) {
73457       {
73458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73459       };
73460     } catch (...) {
73461       {
73462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73463       };
73464     }
73465   }
73466 }
73467
73468
73469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
73470   void * jresult ;
73471   Dali::Toolkit::ScrollView result;
73472
73473   {
73474     try {
73475       result = Dali::Toolkit::ScrollView::New();
73476     } catch (std::out_of_range& e) {
73477       {
73478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73479       };
73480     } catch (std::exception& e) {
73481       {
73482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73483       };
73484     } catch (...) {
73485       {
73486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73487       };
73488     }
73489   }
73490   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
73491   return jresult;
73492 }
73493
73494
73495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
73496   void * jresult ;
73497   Dali::BaseHandle arg1 ;
73498   Dali::BaseHandle *argp1 ;
73499   Dali::Toolkit::ScrollView result;
73500
73501   argp1 = (Dali::BaseHandle *)jarg1;
73502   if (!argp1) {
73503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73504     return 0;
73505   }
73506   arg1 = *argp1;
73507   {
73508     try {
73509       result = Dali::Toolkit::ScrollView::DownCast(arg1);
73510     } catch (std::out_of_range& e) {
73511       {
73512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73513       };
73514     } catch (std::exception& e) {
73515       {
73516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73517       };
73518     } catch (...) {
73519       {
73520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73521       };
73522     }
73523   }
73524   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
73525   return jresult;
73526 }
73527
73528
73529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
73530   void * jresult ;
73531   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73532   Dali::AlphaFunction result;
73533
73534   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73535   {
73536     try {
73537       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
73538     } catch (std::out_of_range& e) {
73539       {
73540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73541       };
73542     } catch (std::exception& e) {
73543       {
73544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73545       };
73546     } catch (...) {
73547       {
73548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73549       };
73550     }
73551   }
73552   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
73553   return jresult;
73554 }
73555
73556
73557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
73558   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73559   Dali::AlphaFunction arg2 ;
73560   Dali::AlphaFunction *argp2 ;
73561
73562   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73563   argp2 = (Dali::AlphaFunction *)jarg2;
73564   if (!argp2) {
73565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
73566     return ;
73567   }
73568   arg2 = *argp2;
73569   {
73570     try {
73571       (arg1)->SetScrollSnapAlphaFunction(arg2);
73572     } catch (std::out_of_range& e) {
73573       {
73574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73575       };
73576     } catch (std::exception& e) {
73577       {
73578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73579       };
73580     } catch (...) {
73581       {
73582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73583       };
73584     }
73585   }
73586 }
73587
73588
73589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
73590   void * jresult ;
73591   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73592   Dali::AlphaFunction result;
73593
73594   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73595   {
73596     try {
73597       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
73598     } catch (std::out_of_range& e) {
73599       {
73600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73601       };
73602     } catch (std::exception& e) {
73603       {
73604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73605       };
73606     } catch (...) {
73607       {
73608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73609       };
73610     }
73611   }
73612   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
73613   return jresult;
73614 }
73615
73616
73617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
73618   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73619   Dali::AlphaFunction arg2 ;
73620   Dali::AlphaFunction *argp2 ;
73621
73622   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73623   argp2 = (Dali::AlphaFunction *)jarg2;
73624   if (!argp2) {
73625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
73626     return ;
73627   }
73628   arg2 = *argp2;
73629   {
73630     try {
73631       (arg1)->SetScrollFlickAlphaFunction(arg2);
73632     } catch (std::out_of_range& e) {
73633       {
73634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73635       };
73636     } catch (std::exception& e) {
73637       {
73638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73639       };
73640     } catch (...) {
73641       {
73642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73643       };
73644     }
73645   }
73646 }
73647
73648
73649 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
73650   float jresult ;
73651   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73652   float result;
73653
73654   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73655   {
73656     try {
73657       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
73658     } catch (std::out_of_range& e) {
73659       {
73660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73661       };
73662     } catch (std::exception& e) {
73663       {
73664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73665       };
73666     } catch (...) {
73667       {
73668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73669       };
73670     }
73671   }
73672   jresult = result;
73673   return jresult;
73674 }
73675
73676
73677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
73678   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73679   float arg2 ;
73680
73681   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73682   arg2 = (float)jarg2;
73683   {
73684     try {
73685       (arg1)->SetScrollSnapDuration(arg2);
73686     } catch (std::out_of_range& e) {
73687       {
73688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73689       };
73690     } catch (std::exception& e) {
73691       {
73692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73693       };
73694     } catch (...) {
73695       {
73696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73697       };
73698     }
73699   }
73700 }
73701
73702
73703 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
73704   float jresult ;
73705   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73706   float result;
73707
73708   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73709   {
73710     try {
73711       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
73712     } catch (std::out_of_range& e) {
73713       {
73714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73715       };
73716     } catch (std::exception& e) {
73717       {
73718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73719       };
73720     } catch (...) {
73721       {
73722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73723       };
73724     }
73725   }
73726   jresult = result;
73727   return jresult;
73728 }
73729
73730
73731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
73732   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73733   float arg2 ;
73734
73735   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73736   arg2 = (float)jarg2;
73737   {
73738     try {
73739       (arg1)->SetScrollFlickDuration(arg2);
73740     } catch (std::out_of_range& e) {
73741       {
73742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73743       };
73744     } catch (std::exception& e) {
73745       {
73746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73747       };
73748     } catch (...) {
73749       {
73750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73751       };
73752     }
73753   }
73754 }
73755
73756
73757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
73758   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73759   Dali::Toolkit::RulerPtr arg2 ;
73760   Dali::Toolkit::RulerPtr *argp2 ;
73761
73762   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73763   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
73764   if (!argp2) {
73765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
73766     return ;
73767   }
73768   arg2 = *argp2;
73769   {
73770     try {
73771       (arg1)->SetRulerX(arg2);
73772     } catch (std::out_of_range& e) {
73773       {
73774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73775       };
73776     } catch (std::exception& e) {
73777       {
73778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73779       };
73780     } catch (...) {
73781       {
73782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73783       };
73784     }
73785   }
73786 }
73787
73788
73789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
73790   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73791   Dali::Toolkit::RulerPtr arg2 ;
73792   Dali::Toolkit::RulerPtr *argp2 ;
73793
73794   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73795   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
73796   if (!argp2) {
73797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
73798     return ;
73799   }
73800   arg2 = *argp2;
73801   {
73802     try {
73803       (arg1)->SetRulerY(arg2);
73804     } catch (std::out_of_range& e) {
73805       {
73806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73807       };
73808     } catch (std::exception& e) {
73809       {
73810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73811       };
73812     } catch (...) {
73813       {
73814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73815       };
73816     }
73817   }
73818 }
73819
73820
73821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
73822   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73823   bool arg2 ;
73824
73825   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73826   arg2 = jarg2 ? true : false;
73827   {
73828     try {
73829       (arg1)->SetScrollSensitive(arg2);
73830     } catch (std::out_of_range& e) {
73831       {
73832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73833       };
73834     } catch (std::exception& e) {
73835       {
73836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73837       };
73838     } catch (...) {
73839       {
73840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73841       };
73842     }
73843   }
73844 }
73845
73846
73847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
73848   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73849   float arg2 ;
73850   float arg3 ;
73851
73852   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73853   arg2 = (float)jarg2;
73854   arg3 = (float)jarg3;
73855   {
73856     try {
73857       (arg1)->SetMaxOvershoot(arg2,arg3);
73858     } catch (std::out_of_range& e) {
73859       {
73860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73861       };
73862     } catch (std::exception& e) {
73863       {
73864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73865       };
73866     } catch (...) {
73867       {
73868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73869       };
73870     }
73871   }
73872 }
73873
73874
73875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
73876   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73877   Dali::AlphaFunction arg2 ;
73878   Dali::AlphaFunction *argp2 ;
73879
73880   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73881   argp2 = (Dali::AlphaFunction *)jarg2;
73882   if (!argp2) {
73883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
73884     return ;
73885   }
73886   arg2 = *argp2;
73887   {
73888     try {
73889       (arg1)->SetSnapOvershootAlphaFunction(arg2);
73890     } catch (std::out_of_range& e) {
73891       {
73892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73893       };
73894     } catch (std::exception& e) {
73895       {
73896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73897       };
73898     } catch (...) {
73899       {
73900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73901       };
73902     }
73903   }
73904 }
73905
73906
73907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
73908   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73909   float arg2 ;
73910
73911   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73912   arg2 = (float)jarg2;
73913   {
73914     try {
73915       (arg1)->SetSnapOvershootDuration(arg2);
73916     } catch (std::out_of_range& e) {
73917       {
73918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73919       };
73920     } catch (std::exception& e) {
73921       {
73922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73923       };
73924     } catch (...) {
73925       {
73926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73927       };
73928     }
73929   }
73930 }
73931
73932
73933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
73934   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73935   bool arg2 ;
73936
73937   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73938   arg2 = jarg2 ? true : false;
73939   {
73940     try {
73941       (arg1)->SetActorAutoSnap(arg2);
73942     } catch (std::out_of_range& e) {
73943       {
73944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73945       };
73946     } catch (std::exception& e) {
73947       {
73948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73949       };
73950     } catch (...) {
73951       {
73952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73953       };
73954     }
73955   }
73956 }
73957
73958
73959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
73960   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73961   bool arg2 ;
73962
73963   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73964   arg2 = jarg2 ? true : false;
73965   {
73966     try {
73967       (arg1)->SetWrapMode(arg2);
73968     } catch (std::out_of_range& e) {
73969       {
73970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73971       };
73972     } catch (std::exception& e) {
73973       {
73974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73975       };
73976     } catch (...) {
73977       {
73978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73979       };
73980     }
73981   }
73982 }
73983
73984
73985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
73986   int jresult ;
73987   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73988   int result;
73989
73990   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73991   {
73992     try {
73993       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
73994     } catch (std::out_of_range& e) {
73995       {
73996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73997       };
73998     } catch (std::exception& e) {
73999       {
74000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74001       };
74002     } catch (...) {
74003       {
74004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74005       };
74006     }
74007   }
74008   jresult = result;
74009   return jresult;
74010 }
74011
74012
74013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
74014   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74015   int arg2 ;
74016
74017   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74018   arg2 = (int)jarg2;
74019   {
74020     try {
74021       (arg1)->SetScrollUpdateDistance(arg2);
74022     } catch (std::out_of_range& e) {
74023       {
74024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74025       };
74026     } catch (std::exception& e) {
74027       {
74028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74029       };
74030     } catch (...) {
74031       {
74032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74033       };
74034     }
74035   }
74036 }
74037
74038
74039 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
74040   unsigned int jresult ;
74041   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74042   bool result;
74043
74044   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74045   {
74046     try {
74047       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
74048     } catch (std::out_of_range& e) {
74049       {
74050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74051       };
74052     } catch (std::exception& e) {
74053       {
74054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74055       };
74056     } catch (...) {
74057       {
74058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74059       };
74060     }
74061   }
74062   jresult = result;
74063   return jresult;
74064 }
74065
74066
74067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
74068   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74069   bool arg2 ;
74070
74071   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74072   arg2 = jarg2 ? true : false;
74073   {
74074     try {
74075       (arg1)->SetAxisAutoLock(arg2);
74076     } catch (std::out_of_range& e) {
74077       {
74078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74079       };
74080     } catch (std::exception& e) {
74081       {
74082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74083       };
74084     } catch (...) {
74085       {
74086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74087       };
74088     }
74089   }
74090 }
74091
74092
74093 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
74094   float jresult ;
74095   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74096   float result;
74097
74098   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74099   {
74100     try {
74101       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
74102     } catch (std::out_of_range& e) {
74103       {
74104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74105       };
74106     } catch (std::exception& e) {
74107       {
74108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74109       };
74110     } catch (...) {
74111       {
74112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74113       };
74114     }
74115   }
74116   jresult = result;
74117   return jresult;
74118 }
74119
74120
74121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
74122   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74123   float arg2 ;
74124
74125   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74126   arg2 = (float)jarg2;
74127   {
74128     try {
74129       (arg1)->SetAxisAutoLockGradient(arg2);
74130     } catch (std::out_of_range& e) {
74131       {
74132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74133       };
74134     } catch (std::exception& e) {
74135       {
74136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74137       };
74138     } catch (...) {
74139       {
74140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74141       };
74142     }
74143   }
74144 }
74145
74146
74147 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
74148   float jresult ;
74149   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74150   float result;
74151
74152   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74153   {
74154     try {
74155       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
74156     } catch (std::out_of_range& e) {
74157       {
74158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74159       };
74160     } catch (std::exception& e) {
74161       {
74162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74163       };
74164     } catch (...) {
74165       {
74166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74167       };
74168     }
74169   }
74170   jresult = result;
74171   return jresult;
74172 }
74173
74174
74175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
74176   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74177   float arg2 ;
74178
74179   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74180   arg2 = (float)jarg2;
74181   {
74182     try {
74183       (arg1)->SetFrictionCoefficient(arg2);
74184     } catch (std::out_of_range& e) {
74185       {
74186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74187       };
74188     } catch (std::exception& e) {
74189       {
74190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74191       };
74192     } catch (...) {
74193       {
74194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74195       };
74196     }
74197   }
74198 }
74199
74200
74201 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
74202   float jresult ;
74203   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74204   float result;
74205
74206   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74207   {
74208     try {
74209       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
74210     } catch (std::out_of_range& e) {
74211       {
74212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74213       };
74214     } catch (std::exception& e) {
74215       {
74216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74217       };
74218     } catch (...) {
74219       {
74220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74221       };
74222     }
74223   }
74224   jresult = result;
74225   return jresult;
74226 }
74227
74228
74229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
74230   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74231   float arg2 ;
74232
74233   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74234   arg2 = (float)jarg2;
74235   {
74236     try {
74237       (arg1)->SetFlickSpeedCoefficient(arg2);
74238     } catch (std::out_of_range& e) {
74239       {
74240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74241       };
74242     } catch (std::exception& e) {
74243       {
74244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74245       };
74246     } catch (...) {
74247       {
74248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74249       };
74250     }
74251   }
74252 }
74253
74254
74255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
74256   void * jresult ;
74257   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74258   Dali::Vector2 result;
74259
74260   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74261   {
74262     try {
74263       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
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 = new Dali::Vector2((const Dali::Vector2 &)result);
74279   return jresult;
74280 }
74281
74282
74283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
74284   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74285   Dali::Vector2 *arg2 = 0 ;
74286
74287   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74288   arg2 = (Dali::Vector2 *)jarg2;
74289   if (!arg2) {
74290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74291     return ;
74292   }
74293   {
74294     try {
74295       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
74296     } catch (std::out_of_range& e) {
74297       {
74298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74299       };
74300     } catch (std::exception& e) {
74301       {
74302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74303       };
74304     } catch (...) {
74305       {
74306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74307       };
74308     }
74309   }
74310 }
74311
74312
74313 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
74314   float jresult ;
74315   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74316   float result;
74317
74318   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74319   {
74320     try {
74321       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
74322     } catch (std::out_of_range& e) {
74323       {
74324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74325       };
74326     } catch (std::exception& e) {
74327       {
74328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74329       };
74330     } catch (...) {
74331       {
74332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74333       };
74334     }
74335   }
74336   jresult = result;
74337   return jresult;
74338 }
74339
74340
74341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
74342   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74343   float arg2 ;
74344
74345   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74346   arg2 = (float)jarg2;
74347   {
74348     try {
74349       (arg1)->SetMinimumSpeedForFlick(arg2);
74350     } catch (std::out_of_range& e) {
74351       {
74352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74353       };
74354     } catch (std::exception& e) {
74355       {
74356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74357       };
74358     } catch (...) {
74359       {
74360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74361       };
74362     }
74363   }
74364 }
74365
74366
74367 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
74368   float jresult ;
74369   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74370   float result;
74371
74372   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74373   {
74374     try {
74375       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
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 = result;
74391   return jresult;
74392 }
74393
74394
74395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
74396   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74397   float arg2 ;
74398
74399   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74400   arg2 = (float)jarg2;
74401   {
74402     try {
74403       (arg1)->SetMaxFlickSpeed(arg2);
74404     } catch (std::out_of_range& e) {
74405       {
74406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74407       };
74408     } catch (std::exception& e) {
74409       {
74410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74411       };
74412     } catch (...) {
74413       {
74414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74415       };
74416     }
74417   }
74418 }
74419
74420
74421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
74422   void * jresult ;
74423   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74424   Dali::Vector2 result;
74425
74426   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74427   {
74428     try {
74429       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
74430     } catch (std::out_of_range& e) {
74431       {
74432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74433       };
74434     } catch (std::exception& e) {
74435       {
74436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74437       };
74438     } catch (...) {
74439       {
74440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74441       };
74442     }
74443   }
74444   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
74445   return jresult;
74446 }
74447
74448
74449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
74450   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74451   Dali::Vector2 arg2 ;
74452   Dali::Vector2 *argp2 ;
74453
74454   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74455   argp2 = (Dali::Vector2 *)jarg2;
74456   if (!argp2) {
74457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
74458     return ;
74459   }
74460   arg2 = *argp2;
74461   {
74462     try {
74463       (arg1)->SetWheelScrollDistanceStep(arg2);
74464     } catch (std::out_of_range& e) {
74465       {
74466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74467       };
74468     } catch (std::exception& e) {
74469       {
74470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74471       };
74472     } catch (...) {
74473       {
74474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74475       };
74476     }
74477   }
74478 }
74479
74480
74481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
74482   void * jresult ;
74483   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74484   Dali::Vector2 result;
74485
74486   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74487   {
74488     try {
74489       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
74490     } catch (std::out_of_range& e) {
74491       {
74492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74493       };
74494     } catch (std::exception& e) {
74495       {
74496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74497       };
74498     } catch (...) {
74499       {
74500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74501       };
74502     }
74503   }
74504   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
74505   return jresult;
74506 }
74507
74508
74509 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
74510   unsigned int jresult ;
74511   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74512   unsigned int result;
74513
74514   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74515   {
74516     try {
74517       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
74518     } catch (std::out_of_range& e) {
74519       {
74520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74521       };
74522     } catch (std::exception& e) {
74523       {
74524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74525       };
74526     } catch (...) {
74527       {
74528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74529       };
74530     }
74531   }
74532   jresult = result;
74533   return jresult;
74534 }
74535
74536
74537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
74538   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74539   Dali::Vector2 *arg2 = 0 ;
74540
74541   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74542   arg2 = (Dali::Vector2 *)jarg2;
74543   if (!arg2) {
74544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74545     return ;
74546   }
74547   {
74548     try {
74549       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
74550     } catch (std::out_of_range& e) {
74551       {
74552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74553       };
74554     } catch (std::exception& e) {
74555       {
74556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74557       };
74558     } catch (...) {
74559       {
74560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74561       };
74562     }
74563   }
74564 }
74565
74566
74567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
74568   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74569   Dali::Vector2 *arg2 = 0 ;
74570   float arg3 ;
74571
74572   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74573   arg2 = (Dali::Vector2 *)jarg2;
74574   if (!arg2) {
74575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74576     return ;
74577   }
74578   arg3 = (float)jarg3;
74579   {
74580     try {
74581       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
74582     } catch (std::out_of_range& e) {
74583       {
74584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74585       };
74586     } catch (std::exception& e) {
74587       {
74588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74589       };
74590     } catch (...) {
74591       {
74592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74593       };
74594     }
74595   }
74596 }
74597
74598
74599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
74600   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74601   Dali::Vector2 *arg2 = 0 ;
74602   float arg3 ;
74603   Dali::AlphaFunction arg4 ;
74604   Dali::AlphaFunction *argp4 ;
74605
74606   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74607   arg2 = (Dali::Vector2 *)jarg2;
74608   if (!arg2) {
74609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74610     return ;
74611   }
74612   arg3 = (float)jarg3;
74613   argp4 = (Dali::AlphaFunction *)jarg4;
74614   if (!argp4) {
74615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74616     return ;
74617   }
74618   arg4 = *argp4;
74619   {
74620     try {
74621       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
74622     } catch (std::out_of_range& e) {
74623       {
74624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74625       };
74626     } catch (std::exception& e) {
74627       {
74628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74629       };
74630     } catch (...) {
74631       {
74632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74633       };
74634     }
74635   }
74636 }
74637
74638
74639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
74640   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74641   Dali::Vector2 *arg2 = 0 ;
74642   float arg3 ;
74643   Dali::Toolkit::DirectionBias arg4 ;
74644   Dali::Toolkit::DirectionBias arg5 ;
74645
74646   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74647   arg2 = (Dali::Vector2 *)jarg2;
74648   if (!arg2) {
74649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74650     return ;
74651   }
74652   arg3 = (float)jarg3;
74653   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
74654   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
74655   {
74656     try {
74657       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
74658     } catch (std::out_of_range& e) {
74659       {
74660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74661       };
74662     } catch (std::exception& e) {
74663       {
74664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74665       };
74666     } catch (...) {
74667       {
74668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74669       };
74670     }
74671   }
74672 }
74673
74674
74675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
74676   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74677   Dali::Vector2 *arg2 = 0 ;
74678   float arg3 ;
74679   Dali::AlphaFunction arg4 ;
74680   Dali::Toolkit::DirectionBias arg5 ;
74681   Dali::Toolkit::DirectionBias arg6 ;
74682   Dali::AlphaFunction *argp4 ;
74683
74684   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74685   arg2 = (Dali::Vector2 *)jarg2;
74686   if (!arg2) {
74687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74688     return ;
74689   }
74690   arg3 = (float)jarg3;
74691   argp4 = (Dali::AlphaFunction *)jarg4;
74692   if (!argp4) {
74693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74694     return ;
74695   }
74696   arg4 = *argp4;
74697   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
74698   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
74699   {
74700     try {
74701       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
74702     } catch (std::out_of_range& e) {
74703       {
74704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74705       };
74706     } catch (std::exception& e) {
74707       {
74708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74709       };
74710     } catch (...) {
74711       {
74712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74713       };
74714     }
74715   }
74716 }
74717
74718
74719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
74720   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74721   unsigned int arg2 ;
74722
74723   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74724   arg2 = (unsigned int)jarg2;
74725   {
74726     try {
74727       (arg1)->ScrollTo(arg2);
74728     } catch (std::out_of_range& e) {
74729       {
74730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74731       };
74732     } catch (std::exception& e) {
74733       {
74734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74735       };
74736     } catch (...) {
74737       {
74738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74739       };
74740     }
74741   }
74742 }
74743
74744
74745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
74746   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74747   unsigned int arg2 ;
74748   float arg3 ;
74749
74750   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74751   arg2 = (unsigned int)jarg2;
74752   arg3 = (float)jarg3;
74753   {
74754     try {
74755       (arg1)->ScrollTo(arg2,arg3);
74756     } catch (std::out_of_range& e) {
74757       {
74758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74759       };
74760     } catch (std::exception& e) {
74761       {
74762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74763       };
74764     } catch (...) {
74765       {
74766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74767       };
74768     }
74769   }
74770 }
74771
74772
74773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
74774   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74775   unsigned int arg2 ;
74776   float arg3 ;
74777   Dali::Toolkit::DirectionBias arg4 ;
74778
74779   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74780   arg2 = (unsigned int)jarg2;
74781   arg3 = (float)jarg3;
74782   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
74783   {
74784     try {
74785       (arg1)->ScrollTo(arg2,arg3,arg4);
74786     } catch (std::out_of_range& e) {
74787       {
74788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74789       };
74790     } catch (std::exception& e) {
74791       {
74792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74793       };
74794     } catch (...) {
74795       {
74796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74797       };
74798     }
74799   }
74800 }
74801
74802
74803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
74804   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74805   Dali::Actor *arg2 = 0 ;
74806
74807   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74808   arg2 = (Dali::Actor *)jarg2;
74809   if (!arg2) {
74810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
74811     return ;
74812   }
74813   {
74814     try {
74815       (arg1)->ScrollTo(*arg2);
74816     } catch (std::out_of_range& e) {
74817       {
74818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74819       };
74820     } catch (std::exception& e) {
74821       {
74822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74823       };
74824     } catch (...) {
74825       {
74826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74827       };
74828     }
74829   }
74830 }
74831
74832
74833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
74834   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74835   Dali::Actor *arg2 = 0 ;
74836   float arg3 ;
74837
74838   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74839   arg2 = (Dali::Actor *)jarg2;
74840   if (!arg2) {
74841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
74842     return ;
74843   }
74844   arg3 = (float)jarg3;
74845   {
74846     try {
74847       (arg1)->ScrollTo(*arg2,arg3);
74848     } catch (std::out_of_range& e) {
74849       {
74850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74851       };
74852     } catch (std::exception& e) {
74853       {
74854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74855       };
74856     } catch (...) {
74857       {
74858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74859       };
74860     }
74861   }
74862 }
74863
74864
74865 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
74866   unsigned int jresult ;
74867   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74868   bool result;
74869
74870   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74871   {
74872     try {
74873       result = (bool)(arg1)->ScrollToSnapPoint();
74874     } catch (std::out_of_range& e) {
74875       {
74876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74877       };
74878     } catch (std::exception& e) {
74879       {
74880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74881       };
74882     } catch (...) {
74883       {
74884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74885       };
74886     }
74887   }
74888   jresult = result;
74889   return jresult;
74890 }
74891
74892
74893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
74894   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74895   Dali::Constraint arg2 ;
74896   Dali::Constraint *argp2 ;
74897
74898   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74899   argp2 = (Dali::Constraint *)jarg2;
74900   if (!argp2) {
74901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
74902     return ;
74903   }
74904   arg2 = *argp2;
74905   {
74906     try {
74907       (arg1)->ApplyConstraintToChildren(arg2);
74908     } catch (std::out_of_range& e) {
74909       {
74910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74911       };
74912     } catch (std::exception& e) {
74913       {
74914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74915       };
74916     } catch (...) {
74917       {
74918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74919       };
74920     }
74921   }
74922 }
74923
74924
74925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
74926   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74927
74928   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74929   {
74930     try {
74931       (arg1)->RemoveConstraintsFromChildren();
74932     } catch (std::out_of_range& e) {
74933       {
74934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74935       };
74936     } catch (std::exception& e) {
74937       {
74938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74939       };
74940     } catch (...) {
74941       {
74942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74943       };
74944     }
74945   }
74946 }
74947
74948
74949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
74950   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74951   Dali::Toolkit::ScrollViewEffect arg2 ;
74952   Dali::Toolkit::ScrollViewEffect *argp2 ;
74953
74954   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74955   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
74956   if (!argp2) {
74957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
74958     return ;
74959   }
74960   arg2 = *argp2;
74961   {
74962     try {
74963       (arg1)->ApplyEffect(arg2);
74964     } catch (std::out_of_range& e) {
74965       {
74966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74967       };
74968     } catch (std::exception& e) {
74969       {
74970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74971       };
74972     } catch (...) {
74973       {
74974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74975       };
74976     }
74977   }
74978 }
74979
74980
74981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
74982   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74983   Dali::Toolkit::ScrollViewEffect arg2 ;
74984   Dali::Toolkit::ScrollViewEffect *argp2 ;
74985
74986   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74987   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
74988   if (!argp2) {
74989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
74990     return ;
74991   }
74992   arg2 = *argp2;
74993   {
74994     try {
74995       (arg1)->RemoveEffect(arg2);
74996     } catch (std::out_of_range& e) {
74997       {
74998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74999       };
75000     } catch (std::exception& e) {
75001       {
75002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75003       };
75004     } catch (...) {
75005       {
75006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75007       };
75008     }
75009   }
75010 }
75011
75012
75013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
75014   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75015
75016   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75017   {
75018     try {
75019       (arg1)->RemoveAllEffects();
75020     } catch (std::out_of_range& e) {
75021       {
75022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75023       };
75024     } catch (std::exception& e) {
75025       {
75026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75027       };
75028     } catch (...) {
75029       {
75030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75031       };
75032     }
75033   }
75034 }
75035
75036
75037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
75038   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75039   Dali::Actor arg2 ;
75040   Dali::Actor *argp2 ;
75041
75042   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75043   argp2 = (Dali::Actor *)jarg2;
75044   if (!argp2) {
75045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75046     return ;
75047   }
75048   arg2 = *argp2;
75049   {
75050     try {
75051       (arg1)->BindActor(arg2);
75052     } catch (std::out_of_range& e) {
75053       {
75054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75055       };
75056     } catch (std::exception& e) {
75057       {
75058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75059       };
75060     } catch (...) {
75061       {
75062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75063       };
75064     }
75065   }
75066 }
75067
75068
75069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
75070   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75071   Dali::Actor arg2 ;
75072   Dali::Actor *argp2 ;
75073
75074   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75075   argp2 = (Dali::Actor *)jarg2;
75076   if (!argp2) {
75077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75078     return ;
75079   }
75080   arg2 = *argp2;
75081   {
75082     try {
75083       (arg1)->UnbindActor(arg2);
75084     } catch (std::out_of_range& e) {
75085       {
75086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75087       };
75088     } catch (std::exception& e) {
75089       {
75090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75091       };
75092     } catch (...) {
75093       {
75094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75095       };
75096     }
75097   }
75098 }
75099
75100
75101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
75102   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75103   Dali::Radian arg2 ;
75104   Dali::Radian arg3 ;
75105   Dali::Radian *argp2 ;
75106   Dali::Radian *argp3 ;
75107
75108   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75109   argp2 = (Dali::Radian *)jarg2;
75110   if (!argp2) {
75111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
75112     return ;
75113   }
75114   arg2 = *argp2;
75115   argp3 = (Dali::Radian *)jarg3;
75116   if (!argp3) {
75117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
75118     return ;
75119   }
75120   arg3 = *argp3;
75121   {
75122     try {
75123       (arg1)->SetScrollingDirection(arg2,arg3);
75124     } catch (std::out_of_range& e) {
75125       {
75126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75127       };
75128     } catch (std::exception& e) {
75129       {
75130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75131       };
75132     } catch (...) {
75133       {
75134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75135       };
75136     }
75137   }
75138 }
75139
75140
75141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
75142   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75143   Dali::Radian arg2 ;
75144   Dali::Radian *argp2 ;
75145
75146   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75147   argp2 = (Dali::Radian *)jarg2;
75148   if (!argp2) {
75149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
75150     return ;
75151   }
75152   arg2 = *argp2;
75153   {
75154     try {
75155       (arg1)->SetScrollingDirection(arg2);
75156     } catch (std::out_of_range& e) {
75157       {
75158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75159       };
75160     } catch (std::exception& e) {
75161       {
75162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75163       };
75164     } catch (...) {
75165       {
75166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75167       };
75168     }
75169   }
75170 }
75171
75172
75173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
75174   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75175   Dali::Radian arg2 ;
75176   Dali::Radian *argp2 ;
75177
75178   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75179   argp2 = (Dali::Radian *)jarg2;
75180   if (!argp2) {
75181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
75182     return ;
75183   }
75184   arg2 = *argp2;
75185   {
75186     try {
75187       (arg1)->RemoveScrollingDirection(arg2);
75188     } catch (std::out_of_range& e) {
75189       {
75190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75191       };
75192     } catch (std::exception& e) {
75193       {
75194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75195       };
75196     } catch (...) {
75197       {
75198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75199       };
75200     }
75201   }
75202 }
75203
75204
75205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
75206   void * jresult ;
75207   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75208   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
75209
75210   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75211   {
75212     try {
75213       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
75214     } catch (std::out_of_range& e) {
75215       {
75216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75217       };
75218     } catch (std::exception& e) {
75219       {
75220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75221       };
75222     } catch (...) {
75223       {
75224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75225       };
75226     }
75227   }
75228   jresult = (void *)result;
75229   return jresult;
75230 }
75231
75232
75233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
75234   int jresult ;
75235   int result;
75236
75237   result = (int)Dali::Toolkit::TableView::Property::ROWS;
75238   jresult = (int)result;
75239   return jresult;
75240 }
75241
75242
75243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
75244   int jresult ;
75245   int result;
75246
75247   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
75248   jresult = (int)result;
75249   return jresult;
75250 }
75251
75252
75253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
75254   int jresult ;
75255   int result;
75256
75257   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
75258   jresult = (int)result;
75259   return jresult;
75260 }
75261
75262
75263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
75264   int jresult ;
75265   int result;
75266
75267   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
75268   jresult = (int)result;
75269   return jresult;
75270 }
75271
75272
75273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
75274   int jresult ;
75275   int result;
75276
75277   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
75278   jresult = (int)result;
75279   return jresult;
75280 }
75281
75282
75283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
75284   void * jresult ;
75285   Dali::Toolkit::TableView::Property *result = 0 ;
75286
75287   {
75288     try {
75289       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
75290     } catch (std::out_of_range& e) {
75291       {
75292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75293       };
75294     } catch (std::exception& e) {
75295       {
75296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75297       };
75298     } catch (...) {
75299       {
75300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75301       };
75302     }
75303   }
75304   jresult = (void *)result;
75305   return jresult;
75306 }
75307
75308
75309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
75310   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
75311
75312   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
75313   {
75314     try {
75315       delete arg1;
75316     } catch (std::out_of_range& e) {
75317       {
75318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75319       };
75320     } catch (std::exception& e) {
75321       {
75322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75323       };
75324     } catch (...) {
75325       {
75326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75327       };
75328     }
75329   }
75330 }
75331
75332
75333 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
75334   int jresult ;
75335   int result;
75336
75337   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
75338   jresult = (int)result;
75339   return jresult;
75340 }
75341
75342
75343 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
75344   int jresult ;
75345   int result;
75346
75347   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
75348   jresult = (int)result;
75349   return jresult;
75350 }
75351
75352
75353 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
75354   int jresult ;
75355   int result;
75356
75357   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
75358   jresult = (int)result;
75359   return jresult;
75360 }
75361
75362
75363 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
75364   int jresult ;
75365   int result;
75366
75367   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
75368   jresult = (int)result;
75369   return jresult;
75370 }
75371
75372
75373 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
75374   int jresult ;
75375   int result;
75376
75377   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
75378   jresult = (int)result;
75379   return jresult;
75380 }
75381
75382
75383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
75384   void * jresult ;
75385   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
75386
75387   {
75388     try {
75389       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
75390     } catch (std::out_of_range& e) {
75391       {
75392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75393       };
75394     } catch (std::exception& e) {
75395       {
75396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75397       };
75398     } catch (...) {
75399       {
75400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75401       };
75402     }
75403   }
75404   jresult = (void *)result;
75405   return jresult;
75406 }
75407
75408
75409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
75410   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
75411
75412   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
75413   {
75414     try {
75415       delete arg1;
75416     } catch (std::out_of_range& e) {
75417       {
75418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75419       };
75420     } catch (std::exception& e) {
75421       {
75422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75423       };
75424     } catch (...) {
75425       {
75426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75427       };
75428     }
75429   }
75430 }
75431
75432
75433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
75434   void * jresult ;
75435   unsigned int arg1 ;
75436   unsigned int arg2 ;
75437   unsigned int arg3 ;
75438   unsigned int arg4 ;
75439   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75440
75441   arg1 = (unsigned int)jarg1;
75442   arg2 = (unsigned int)jarg2;
75443   arg3 = (unsigned int)jarg3;
75444   arg4 = (unsigned int)jarg4;
75445   {
75446     try {
75447       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
75448     } catch (std::out_of_range& e) {
75449       {
75450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75451       };
75452     } catch (std::exception& e) {
75453       {
75454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75455       };
75456     } catch (...) {
75457       {
75458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75459       };
75460     }
75461   }
75462   jresult = (void *)result;
75463   return jresult;
75464 }
75465
75466
75467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
75468   void * jresult ;
75469   unsigned int arg1 ;
75470   unsigned int arg2 ;
75471   unsigned int arg3 ;
75472   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75473
75474   arg1 = (unsigned int)jarg1;
75475   arg2 = (unsigned int)jarg2;
75476   arg3 = (unsigned int)jarg3;
75477   {
75478     try {
75479       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
75480     } catch (std::out_of_range& e) {
75481       {
75482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75483       };
75484     } catch (std::exception& e) {
75485       {
75486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75487       };
75488     } catch (...) {
75489       {
75490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75491       };
75492     }
75493   }
75494   jresult = (void *)result;
75495   return jresult;
75496 }
75497
75498
75499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
75500   void * jresult ;
75501   unsigned int arg1 ;
75502   unsigned int arg2 ;
75503   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75504
75505   arg1 = (unsigned int)jarg1;
75506   arg2 = (unsigned int)jarg2;
75507   {
75508     try {
75509       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
75510     } catch (std::out_of_range& e) {
75511       {
75512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75513       };
75514     } catch (std::exception& e) {
75515       {
75516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75517       };
75518     } catch (...) {
75519       {
75520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75521       };
75522     }
75523   }
75524   jresult = (void *)result;
75525   return jresult;
75526 }
75527
75528
75529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
75530   void * jresult ;
75531   unsigned int arg1 ;
75532   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75533
75534   arg1 = (unsigned int)jarg1;
75535   {
75536     try {
75537       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
75538     } catch (std::out_of_range& e) {
75539       {
75540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75541       };
75542     } catch (std::exception& e) {
75543       {
75544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75545       };
75546     } catch (...) {
75547       {
75548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75549       };
75550     }
75551   }
75552   jresult = (void *)result;
75553   return jresult;
75554 }
75555
75556
75557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
75558   void * jresult ;
75559   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75560
75561   {
75562     try {
75563       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
75564     } catch (std::out_of_range& e) {
75565       {
75566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75567       };
75568     } catch (std::exception& e) {
75569       {
75570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75571       };
75572     } catch (...) {
75573       {
75574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75575       };
75576     }
75577   }
75578   jresult = (void *)result;
75579   return jresult;
75580 }
75581
75582
75583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
75584   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75585   unsigned int arg2 ;
75586
75587   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75588   arg2 = (unsigned int)jarg2;
75589   if (arg1) (arg1)->rowIndex = arg2;
75590 }
75591
75592
75593 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
75594   unsigned int jresult ;
75595   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75596   unsigned int result;
75597
75598   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75599   result = (unsigned int) ((arg1)->rowIndex);
75600   jresult = result;
75601   return jresult;
75602 }
75603
75604
75605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
75606   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75607   unsigned int arg2 ;
75608
75609   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75610   arg2 = (unsigned int)jarg2;
75611   if (arg1) (arg1)->columnIndex = arg2;
75612 }
75613
75614
75615 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
75616   unsigned int jresult ;
75617   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75618   unsigned int result;
75619
75620   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75621   result = (unsigned int) ((arg1)->columnIndex);
75622   jresult = result;
75623   return jresult;
75624 }
75625
75626
75627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
75628   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75629   unsigned int arg2 ;
75630
75631   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75632   arg2 = (unsigned int)jarg2;
75633   if (arg1) (arg1)->rowSpan = arg2;
75634 }
75635
75636
75637 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
75638   unsigned int jresult ;
75639   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75640   unsigned int result;
75641
75642   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75643   result = (unsigned int) ((arg1)->rowSpan);
75644   jresult = result;
75645   return jresult;
75646 }
75647
75648
75649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
75650   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75651   unsigned int arg2 ;
75652
75653   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75654   arg2 = (unsigned int)jarg2;
75655   if (arg1) (arg1)->columnSpan = arg2;
75656 }
75657
75658
75659 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
75660   unsigned int jresult ;
75661   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75662   unsigned int result;
75663
75664   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75665   result = (unsigned int) ((arg1)->columnSpan);
75666   jresult = result;
75667   return jresult;
75668 }
75669
75670
75671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
75672   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75673
75674   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75675   {
75676     try {
75677       delete arg1;
75678     } catch (std::out_of_range& e) {
75679       {
75680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75681       };
75682     } catch (std::exception& e) {
75683       {
75684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75685       };
75686     } catch (...) {
75687       {
75688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75689       };
75690     }
75691   }
75692 }
75693
75694
75695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
75696   void * jresult ;
75697   Dali::Toolkit::TableView *result = 0 ;
75698
75699   {
75700     try {
75701       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
75702     } catch (std::out_of_range& e) {
75703       {
75704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75705       };
75706     } catch (std::exception& e) {
75707       {
75708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75709       };
75710     } catch (...) {
75711       {
75712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75713       };
75714     }
75715   }
75716   jresult = (void *)result;
75717   return jresult;
75718 }
75719
75720
75721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
75722   void * jresult ;
75723   Dali::Toolkit::TableView *arg1 = 0 ;
75724   Dali::Toolkit::TableView *result = 0 ;
75725
75726   arg1 = (Dali::Toolkit::TableView *)jarg1;
75727   if (!arg1) {
75728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
75729     return 0;
75730   }
75731   {
75732     try {
75733       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
75734     } catch (std::out_of_range& e) {
75735       {
75736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75737       };
75738     } catch (std::exception& e) {
75739       {
75740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75741       };
75742     } catch (...) {
75743       {
75744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75745       };
75746     }
75747   }
75748   jresult = (void *)result;
75749   return jresult;
75750 }
75751
75752
75753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
75754   void * jresult ;
75755   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75756   Dali::Toolkit::TableView *arg2 = 0 ;
75757   Dali::Toolkit::TableView *result = 0 ;
75758
75759   arg1 = (Dali::Toolkit::TableView *)jarg1;
75760   arg2 = (Dali::Toolkit::TableView *)jarg2;
75761   if (!arg2) {
75762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
75763     return 0;
75764   }
75765   {
75766     try {
75767       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
75768     } catch (std::out_of_range& e) {
75769       {
75770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75771       };
75772     } catch (std::exception& e) {
75773       {
75774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75775       };
75776     } catch (...) {
75777       {
75778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75779       };
75780     }
75781   }
75782   jresult = (void *)result;
75783   return jresult;
75784 }
75785
75786
75787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
75788   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75789
75790   arg1 = (Dali::Toolkit::TableView *)jarg1;
75791   {
75792     try {
75793       delete arg1;
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_TableView_New(unsigned int jarg1, unsigned int jarg2) {
75812   void * jresult ;
75813   unsigned int arg1 ;
75814   unsigned int arg2 ;
75815   Dali::Toolkit::TableView result;
75816
75817   arg1 = (unsigned int)jarg1;
75818   arg2 = (unsigned int)jarg2;
75819   {
75820     try {
75821       result = Dali::Toolkit::TableView::New(arg1,arg2);
75822     } catch (std::out_of_range& e) {
75823       {
75824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75825       };
75826     } catch (std::exception& e) {
75827       {
75828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75829       };
75830     } catch (...) {
75831       {
75832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75833       };
75834     }
75835   }
75836   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
75837   return jresult;
75838 }
75839
75840
75841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
75842   void * jresult ;
75843   Dali::BaseHandle arg1 ;
75844   Dali::BaseHandle *argp1 ;
75845   Dali::Toolkit::TableView result;
75846
75847   argp1 = (Dali::BaseHandle *)jarg1;
75848   if (!argp1) {
75849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75850     return 0;
75851   }
75852   arg1 = *argp1;
75853   {
75854     try {
75855       result = Dali::Toolkit::TableView::DownCast(arg1);
75856     } catch (std::out_of_range& e) {
75857       {
75858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75859       };
75860     } catch (std::exception& e) {
75861       {
75862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75863       };
75864     } catch (...) {
75865       {
75866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75867       };
75868     }
75869   }
75870   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
75871   return jresult;
75872 }
75873
75874
75875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
75876   unsigned int jresult ;
75877   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75878   Dali::Actor arg2 ;
75879   Dali::Toolkit::TableView::CellPosition arg3 ;
75880   Dali::Actor *argp2 ;
75881   Dali::Toolkit::TableView::CellPosition *argp3 ;
75882   bool result;
75883
75884   arg1 = (Dali::Toolkit::TableView *)jarg1;
75885   argp2 = (Dali::Actor *)jarg2;
75886   if (!argp2) {
75887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75888     return 0;
75889   }
75890   arg2 = *argp2;
75891   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
75892   if (!argp3) {
75893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
75894     return 0;
75895   }
75896   arg3 = *argp3;
75897   {
75898     try {
75899       result = (bool)(arg1)->AddChild(arg2,arg3);
75900     } catch (std::out_of_range& e) {
75901       {
75902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75903       };
75904     } catch (std::exception& e) {
75905       {
75906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75907       };
75908     } catch (...) {
75909       {
75910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75911       };
75912     }
75913   }
75914   jresult = result;
75915   return jresult;
75916 }
75917
75918
75919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
75920   void * jresult ;
75921   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75922   Dali::Toolkit::TableView::CellPosition arg2 ;
75923   Dali::Toolkit::TableView::CellPosition *argp2 ;
75924   Dali::Actor result;
75925
75926   arg1 = (Dali::Toolkit::TableView *)jarg1;
75927   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
75928   if (!argp2) {
75929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
75930     return 0;
75931   }
75932   arg2 = *argp2;
75933   {
75934     try {
75935       result = (arg1)->GetChildAt(arg2);
75936     } catch (std::out_of_range& e) {
75937       {
75938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75939       };
75940     } catch (std::exception& e) {
75941       {
75942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75943       };
75944     } catch (...) {
75945       {
75946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75947       };
75948     }
75949   }
75950   jresult = new Dali::Actor((const Dali::Actor &)result);
75951   return jresult;
75952 }
75953
75954
75955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
75956   void * jresult ;
75957   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75958   Dali::Toolkit::TableView::CellPosition arg2 ;
75959   Dali::Toolkit::TableView::CellPosition *argp2 ;
75960   Dali::Actor result;
75961
75962   arg1 = (Dali::Toolkit::TableView *)jarg1;
75963   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
75964   if (!argp2) {
75965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
75966     return 0;
75967   }
75968   arg2 = *argp2;
75969   {
75970     try {
75971       result = (arg1)->RemoveChildAt(arg2);
75972     } catch (std::out_of_range& e) {
75973       {
75974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75975       };
75976     } catch (std::exception& e) {
75977       {
75978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75979       };
75980     } catch (...) {
75981       {
75982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75983       };
75984     }
75985   }
75986   jresult = new Dali::Actor((const Dali::Actor &)result);
75987   return jresult;
75988 }
75989
75990
75991 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
75992   unsigned int jresult ;
75993   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75994   Dali::Actor arg2 ;
75995   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
75996   Dali::Actor *argp2 ;
75997   bool result;
75998
75999   arg1 = (Dali::Toolkit::TableView *)jarg1;
76000   argp2 = (Dali::Actor *)jarg2;
76001   if (!argp2) {
76002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76003     return 0;
76004   }
76005   arg2 = *argp2;
76006   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
76007   if (!arg3) {
76008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
76009     return 0;
76010   }
76011   {
76012     try {
76013       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
76014     } catch (std::out_of_range& e) {
76015       {
76016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76017       };
76018     } catch (std::exception& e) {
76019       {
76020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76021       };
76022     } catch (...) {
76023       {
76024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76025       };
76026     }
76027   }
76028   jresult = result;
76029   return jresult;
76030 }
76031
76032
76033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
76034   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76035   unsigned int arg2 ;
76036
76037   arg1 = (Dali::Toolkit::TableView *)jarg1;
76038   arg2 = (unsigned int)jarg2;
76039   {
76040     try {
76041       (arg1)->InsertRow(arg2);
76042     } catch (std::out_of_range& e) {
76043       {
76044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76045       };
76046     } catch (std::exception& e) {
76047       {
76048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76049       };
76050     } catch (...) {
76051       {
76052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76053       };
76054     }
76055   }
76056 }
76057
76058
76059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
76060   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76061   unsigned int arg2 ;
76062
76063   arg1 = (Dali::Toolkit::TableView *)jarg1;
76064   arg2 = (unsigned int)jarg2;
76065   {
76066     try {
76067       (arg1)->DeleteRow(arg2);
76068     } catch (std::out_of_range& e) {
76069       {
76070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76071       };
76072     } catch (std::exception& e) {
76073       {
76074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76075       };
76076     } catch (...) {
76077       {
76078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76079       };
76080     }
76081   }
76082 }
76083
76084
76085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
76086   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76087   unsigned int arg2 ;
76088   std::vector< Dali::Actor > *arg3 = 0 ;
76089
76090   arg1 = (Dali::Toolkit::TableView *)jarg1;
76091   arg2 = (unsigned int)jarg2;
76092   arg3 = (std::vector< Dali::Actor > *)jarg3;
76093   if (!arg3) {
76094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
76095     return ;
76096   }
76097   {
76098     try {
76099       (arg1)->DeleteRow(arg2,*arg3);
76100     } catch (std::out_of_range& e) {
76101       {
76102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76103       };
76104     } catch (std::exception& e) {
76105       {
76106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76107       };
76108     } catch (...) {
76109       {
76110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76111       };
76112     }
76113   }
76114 }
76115
76116
76117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
76118   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76119   unsigned int arg2 ;
76120
76121   arg1 = (Dali::Toolkit::TableView *)jarg1;
76122   arg2 = (unsigned int)jarg2;
76123   {
76124     try {
76125       (arg1)->InsertColumn(arg2);
76126     } catch (std::out_of_range& e) {
76127       {
76128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76129       };
76130     } catch (std::exception& e) {
76131       {
76132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76133       };
76134     } catch (...) {
76135       {
76136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76137       };
76138     }
76139   }
76140 }
76141
76142
76143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
76144   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76145   unsigned int arg2 ;
76146
76147   arg1 = (Dali::Toolkit::TableView *)jarg1;
76148   arg2 = (unsigned int)jarg2;
76149   {
76150     try {
76151       (arg1)->DeleteColumn(arg2);
76152     } catch (std::out_of_range& e) {
76153       {
76154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76155       };
76156     } catch (std::exception& e) {
76157       {
76158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76159       };
76160     } catch (...) {
76161       {
76162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76163       };
76164     }
76165   }
76166 }
76167
76168
76169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
76170   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76171   unsigned int arg2 ;
76172   std::vector< Dali::Actor > *arg3 = 0 ;
76173
76174   arg1 = (Dali::Toolkit::TableView *)jarg1;
76175   arg2 = (unsigned int)jarg2;
76176   arg3 = (std::vector< Dali::Actor > *)jarg3;
76177   if (!arg3) {
76178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
76179     return ;
76180   }
76181   {
76182     try {
76183       (arg1)->DeleteColumn(arg2,*arg3);
76184     } catch (std::out_of_range& e) {
76185       {
76186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76187       };
76188     } catch (std::exception& e) {
76189       {
76190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76191       };
76192     } catch (...) {
76193       {
76194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76195       };
76196     }
76197   }
76198 }
76199
76200
76201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
76202   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76203   unsigned int arg2 ;
76204   unsigned int arg3 ;
76205
76206   arg1 = (Dali::Toolkit::TableView *)jarg1;
76207   arg2 = (unsigned int)jarg2;
76208   arg3 = (unsigned int)jarg3;
76209   {
76210     try {
76211       (arg1)->Resize(arg2,arg3);
76212     } catch (std::out_of_range& e) {
76213       {
76214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76215       };
76216     } catch (std::exception& e) {
76217       {
76218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76219       };
76220     } catch (...) {
76221       {
76222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76223       };
76224     }
76225   }
76226 }
76227
76228
76229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
76230   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76231   unsigned int arg2 ;
76232   unsigned int arg3 ;
76233   std::vector< Dali::Actor > *arg4 = 0 ;
76234
76235   arg1 = (Dali::Toolkit::TableView *)jarg1;
76236   arg2 = (unsigned int)jarg2;
76237   arg3 = (unsigned int)jarg3;
76238   arg4 = (std::vector< Dali::Actor > *)jarg4;
76239   if (!arg4) {
76240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
76241     return ;
76242   }
76243   {
76244     try {
76245       (arg1)->Resize(arg2,arg3,*arg4);
76246     } catch (std::out_of_range& e) {
76247       {
76248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76249       };
76250     } catch (std::exception& e) {
76251       {
76252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76253       };
76254     } catch (...) {
76255       {
76256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76257       };
76258     }
76259   }
76260 }
76261
76262
76263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
76264   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76265   Dali::Size arg2 ;
76266   Dali::Size *argp2 ;
76267
76268   arg1 = (Dali::Toolkit::TableView *)jarg1;
76269   argp2 = (Dali::Size *)jarg2;
76270   if (!argp2) {
76271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
76272     return ;
76273   }
76274   arg2 = *argp2;
76275   {
76276     try {
76277       (arg1)->SetCellPadding(arg2);
76278     } catch (std::out_of_range& e) {
76279       {
76280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76281       };
76282     } catch (std::exception& e) {
76283       {
76284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76285       };
76286     } catch (...) {
76287       {
76288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76289       };
76290     }
76291   }
76292 }
76293
76294
76295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
76296   void * jresult ;
76297   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76298   Dali::Size result;
76299
76300   arg1 = (Dali::Toolkit::TableView *)jarg1;
76301   {
76302     try {
76303       result = (arg1)->GetCellPadding();
76304     } catch (std::out_of_range& e) {
76305       {
76306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76307       };
76308     } catch (std::exception& e) {
76309       {
76310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76311       };
76312     } catch (...) {
76313       {
76314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76315       };
76316     }
76317   }
76318   jresult = new Dali::Size((const Dali::Size &)result);
76319   return jresult;
76320 }
76321
76322
76323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
76324   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76325   unsigned int arg2 ;
76326
76327   arg1 = (Dali::Toolkit::TableView *)jarg1;
76328   arg2 = (unsigned int)jarg2;
76329   {
76330     try {
76331       (arg1)->SetFitHeight(arg2);
76332     } catch (std::out_of_range& e) {
76333       {
76334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76335       };
76336     } catch (std::exception& e) {
76337       {
76338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76339       };
76340     } catch (...) {
76341       {
76342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76343       };
76344     }
76345   }
76346 }
76347
76348
76349 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
76350   unsigned int jresult ;
76351   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76352   unsigned int arg2 ;
76353   bool result;
76354
76355   arg1 = (Dali::Toolkit::TableView *)jarg1;
76356   arg2 = (unsigned int)jarg2;
76357   {
76358     try {
76359       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
76360     } catch (std::out_of_range& e) {
76361       {
76362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76363       };
76364     } catch (std::exception& e) {
76365       {
76366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76367       };
76368     } catch (...) {
76369       {
76370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76371       };
76372     }
76373   }
76374   jresult = result;
76375   return jresult;
76376 }
76377
76378
76379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
76380   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76381   unsigned int arg2 ;
76382
76383   arg1 = (Dali::Toolkit::TableView *)jarg1;
76384   arg2 = (unsigned int)jarg2;
76385   {
76386     try {
76387       (arg1)->SetFitWidth(arg2);
76388     } catch (std::out_of_range& e) {
76389       {
76390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76391       };
76392     } catch (std::exception& e) {
76393       {
76394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76395       };
76396     } catch (...) {
76397       {
76398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76399       };
76400     }
76401   }
76402 }
76403
76404
76405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
76406   unsigned int jresult ;
76407   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76408   unsigned int arg2 ;
76409   bool result;
76410
76411   arg1 = (Dali::Toolkit::TableView *)jarg1;
76412   arg2 = (unsigned int)jarg2;
76413   {
76414     try {
76415       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
76416     } catch (std::out_of_range& e) {
76417       {
76418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76419       };
76420     } catch (std::exception& e) {
76421       {
76422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76423       };
76424     } catch (...) {
76425       {
76426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76427       };
76428     }
76429   }
76430   jresult = result;
76431   return jresult;
76432 }
76433
76434
76435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
76436   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76437   unsigned int arg2 ;
76438   float arg3 ;
76439
76440   arg1 = (Dali::Toolkit::TableView *)jarg1;
76441   arg2 = (unsigned int)jarg2;
76442   arg3 = (float)jarg3;
76443   {
76444     try {
76445       (arg1)->SetFixedHeight(arg2,arg3);
76446     } catch (std::out_of_range& e) {
76447       {
76448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76449       };
76450     } catch (std::exception& e) {
76451       {
76452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76453       };
76454     } catch (...) {
76455       {
76456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76457       };
76458     }
76459   }
76460 }
76461
76462
76463 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
76464   float jresult ;
76465   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76466   unsigned int arg2 ;
76467   float result;
76468
76469   arg1 = (Dali::Toolkit::TableView *)jarg1;
76470   arg2 = (unsigned int)jarg2;
76471   {
76472     try {
76473       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
76474     } catch (std::out_of_range& e) {
76475       {
76476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76477       };
76478     } catch (std::exception& e) {
76479       {
76480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76481       };
76482     } catch (...) {
76483       {
76484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76485       };
76486     }
76487   }
76488   jresult = result;
76489   return jresult;
76490 }
76491
76492
76493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
76494   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76495   unsigned int arg2 ;
76496   float arg3 ;
76497
76498   arg1 = (Dali::Toolkit::TableView *)jarg1;
76499   arg2 = (unsigned int)jarg2;
76500   arg3 = (float)jarg3;
76501   {
76502     try {
76503       (arg1)->SetRelativeHeight(arg2,arg3);
76504     } catch (std::out_of_range& e) {
76505       {
76506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76507       };
76508     } catch (std::exception& e) {
76509       {
76510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76511       };
76512     } catch (...) {
76513       {
76514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76515       };
76516     }
76517   }
76518 }
76519
76520
76521 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
76522   float jresult ;
76523   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76524   unsigned int arg2 ;
76525   float result;
76526
76527   arg1 = (Dali::Toolkit::TableView *)jarg1;
76528   arg2 = (unsigned int)jarg2;
76529   {
76530     try {
76531       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
76532     } catch (std::out_of_range& e) {
76533       {
76534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76535       };
76536     } catch (std::exception& e) {
76537       {
76538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76539       };
76540     } catch (...) {
76541       {
76542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76543       };
76544     }
76545   }
76546   jresult = result;
76547   return jresult;
76548 }
76549
76550
76551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
76552   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76553   unsigned int arg2 ;
76554   float arg3 ;
76555
76556   arg1 = (Dali::Toolkit::TableView *)jarg1;
76557   arg2 = (unsigned int)jarg2;
76558   arg3 = (float)jarg3;
76559   {
76560     try {
76561       (arg1)->SetFixedWidth(arg2,arg3);
76562     } catch (std::out_of_range& e) {
76563       {
76564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76565       };
76566     } catch (std::exception& e) {
76567       {
76568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76569       };
76570     } catch (...) {
76571       {
76572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76573       };
76574     }
76575   }
76576 }
76577
76578
76579 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
76580   float jresult ;
76581   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76582   unsigned int arg2 ;
76583   float result;
76584
76585   arg1 = (Dali::Toolkit::TableView *)jarg1;
76586   arg2 = (unsigned int)jarg2;
76587   {
76588     try {
76589       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
76590     } catch (std::out_of_range& e) {
76591       {
76592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76593       };
76594     } catch (std::exception& e) {
76595       {
76596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76597       };
76598     } catch (...) {
76599       {
76600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76601       };
76602     }
76603   }
76604   jresult = result;
76605   return jresult;
76606 }
76607
76608
76609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
76610   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76611   unsigned int arg2 ;
76612   float arg3 ;
76613
76614   arg1 = (Dali::Toolkit::TableView *)jarg1;
76615   arg2 = (unsigned int)jarg2;
76616   arg3 = (float)jarg3;
76617   {
76618     try {
76619       (arg1)->SetRelativeWidth(arg2,arg3);
76620     } catch (std::out_of_range& e) {
76621       {
76622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76623       };
76624     } catch (std::exception& e) {
76625       {
76626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76627       };
76628     } catch (...) {
76629       {
76630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76631       };
76632     }
76633   }
76634 }
76635
76636
76637 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
76638   float jresult ;
76639   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76640   unsigned int arg2 ;
76641   float result;
76642
76643   arg1 = (Dali::Toolkit::TableView *)jarg1;
76644   arg2 = (unsigned int)jarg2;
76645   {
76646     try {
76647       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
76648     } catch (std::out_of_range& e) {
76649       {
76650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76651       };
76652     } catch (std::exception& e) {
76653       {
76654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76655       };
76656     } catch (...) {
76657       {
76658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76659       };
76660     }
76661   }
76662   jresult = result;
76663   return jresult;
76664 }
76665
76666
76667 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
76668   unsigned int jresult ;
76669   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76670   unsigned int result;
76671
76672   arg1 = (Dali::Toolkit::TableView *)jarg1;
76673   {
76674     try {
76675       result = (unsigned int)(arg1)->GetRows();
76676     } catch (std::out_of_range& e) {
76677       {
76678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76679       };
76680     } catch (std::exception& e) {
76681       {
76682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76683       };
76684     } catch (...) {
76685       {
76686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76687       };
76688     }
76689   }
76690   jresult = result;
76691   return jresult;
76692 }
76693
76694
76695 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
76696   unsigned int jresult ;
76697   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76698   unsigned int result;
76699
76700   arg1 = (Dali::Toolkit::TableView *)jarg1;
76701   {
76702     try {
76703       result = (unsigned int)(arg1)->GetColumns();
76704     } catch (std::out_of_range& e) {
76705       {
76706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76707       };
76708     } catch (std::exception& e) {
76709       {
76710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76711       };
76712     } catch (...) {
76713       {
76714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76715       };
76716     }
76717   }
76718   jresult = result;
76719   return jresult;
76720 }
76721
76722
76723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
76724   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76725   Dali::Toolkit::TableView::CellPosition arg2 ;
76726   Dali::HorizontalAlignment::Type arg3 ;
76727   Dali::VerticalAlignment::Type arg4 ;
76728   Dali::Toolkit::TableView::CellPosition *argp2 ;
76729
76730   arg1 = (Dali::Toolkit::TableView *)jarg1;
76731   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
76732   if (!argp2) {
76733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76734     return ;
76735   }
76736   arg2 = *argp2;
76737   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
76738   arg4 = (Dali::VerticalAlignment::Type)jarg4;
76739   {
76740     try {
76741       (arg1)->SetCellAlignment(arg2,arg3,arg4);
76742     } catch (std::out_of_range& e) {
76743       {
76744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76745       };
76746     } catch (std::exception& e) {
76747       {
76748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76749       };
76750     } catch (...) {
76751       {
76752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76753       };
76754     }
76755   }
76756 }
76757
76758
76759 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
76760   unsigned int jresult ;
76761   unsigned int result;
76762
76763   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
76764   jresult = result;
76765   return jresult;
76766 }
76767
76768
76769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_RENDERING_BACKEND_get() {
76770   int jresult ;
76771   int result;
76772
76773   result = (int)Dali::Toolkit::TextEditor::Property::RENDERING_BACKEND;
76774   jresult = (int)result;
76775   return jresult;
76776 }
76777
76778
76779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_get() {
76780   int jresult ;
76781   int result;
76782
76783   result = (int)Dali::Toolkit::TextEditor::Property::TEXT;
76784   jresult = (int)result;
76785   return jresult;
76786 }
76787
76788
76789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_COLOR_get() {
76790   int jresult ;
76791   int result;
76792
76793   result = (int)Dali::Toolkit::TextEditor::Property::TEXT_COLOR;
76794   jresult = (int)result;
76795   return jresult;
76796 }
76797
76798
76799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_FAMILY_get() {
76800   int jresult ;
76801   int result;
76802
76803   result = (int)Dali::Toolkit::TextEditor::Property::FONT_FAMILY;
76804   jresult = (int)result;
76805   return jresult;
76806 }
76807
76808
76809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_STYLE_get() {
76810   int jresult ;
76811   int result;
76812
76813   result = (int)Dali::Toolkit::TextEditor::Property::FONT_STYLE;
76814   jresult = (int)result;
76815   return jresult;
76816 }
76817
76818
76819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_POINT_SIZE_get() {
76820   int jresult ;
76821   int result;
76822
76823   result = (int)Dali::Toolkit::TextEditor::Property::POINT_SIZE;
76824   jresult = (int)result;
76825   return jresult;
76826 }
76827
76828
76829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_HORIZONTAL_ALIGNMENT_get() {
76830   int jresult ;
76831   int result;
76832
76833   result = (int)Dali::Toolkit::TextEditor::Property::HORIZONTAL_ALIGNMENT;
76834   jresult = (int)result;
76835   return jresult;
76836 }
76837
76838
76839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_THRESHOLD_get() {
76840   int jresult ;
76841   int result;
76842
76843   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_THRESHOLD;
76844   jresult = (int)result;
76845   return jresult;
76846 }
76847
76848
76849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_SPEED_get() {
76850   int jresult ;
76851   int result;
76852
76853   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_SPEED;
76854   jresult = (int)result;
76855   return jresult;
76856 }
76857
76858
76859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_PRIMARY_CURSOR_COLOR_get() {
76860   int jresult ;
76861   int result;
76862
76863   result = (int)Dali::Toolkit::TextEditor::Property::PRIMARY_CURSOR_COLOR;
76864   jresult = (int)result;
76865   return jresult;
76866 }
76867
76868
76869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SECONDARY_CURSOR_COLOR_get() {
76870   int jresult ;
76871   int result;
76872
76873   result = (int)Dali::Toolkit::TextEditor::Property::SECONDARY_CURSOR_COLOR;
76874   jresult = (int)result;
76875   return jresult;
76876 }
76877
76878
76879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_CURSOR_BLINK_get() {
76880   int jresult ;
76881   int result;
76882
76883   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_CURSOR_BLINK;
76884   jresult = (int)result;
76885   return jresult;
76886 }
76887
76888
76889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_INTERVAL_get() {
76890   int jresult ;
76891   int result;
76892
76893   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_INTERVAL;
76894   jresult = (int)result;
76895   return jresult;
76896 }
76897
76898
76899 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_DURATION_get() {
76900   int jresult ;
76901   int result;
76902
76903   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_DURATION;
76904   jresult = (int)result;
76905   return jresult;
76906 }
76907
76908
76909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_WIDTH_get() {
76910   int jresult ;
76911   int result;
76912
76913   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_WIDTH;
76914   jresult = (int)result;
76915   return jresult;
76916 }
76917
76918
76919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_IMAGE_get() {
76920   int jresult ;
76921   int result;
76922
76923   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_IMAGE;
76924   jresult = (int)result;
76925   return jresult;
76926 }
76927
76928
76929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
76930   int jresult ;
76931   int result;
76932
76933   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_PRESSED_IMAGE;
76934   jresult = (int)result;
76935   return jresult;
76936 }
76937
76938
76939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
76940   int jresult ;
76941   int result;
76942
76943   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_LEFT;
76944   jresult = (int)result;
76945   return jresult;
76946 }
76947
76948
76949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
76950   int jresult ;
76951   int result;
76952
76953   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_RIGHT;
76954   jresult = (int)result;
76955   return jresult;
76956 }
76957
76958
76959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
76960   int jresult ;
76961   int result;
76962
76963   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
76964   jresult = (int)result;
76965   return jresult;
76966 }
76967
76968
76969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
76970   int jresult ;
76971   int result;
76972
76973   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
76974   jresult = (int)result;
76975   return jresult;
76976 }
76977
76978
76979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
76980   int jresult ;
76981   int result;
76982
76983   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
76984   jresult = (int)result;
76985   return jresult;
76986 }
76987
76988
76989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
76990   int jresult ;
76991   int result;
76992
76993   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
76994   jresult = (int)result;
76995   return jresult;
76996 }
76997
76998
76999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HIGHLIGHT_COLOR_get() {
77000   int jresult ;
77001   int result;
77002
77003   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HIGHLIGHT_COLOR;
77004   jresult = (int)result;
77005   return jresult;
77006 }
77007
77008
77009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_DECORATION_BOUNDING_BOX_get() {
77010   int jresult ;
77011   int result;
77012
77013   result = (int)Dali::Toolkit::TextEditor::Property::DECORATION_BOUNDING_BOX;
77014   jresult = (int)result;
77015   return jresult;
77016 }
77017
77018
77019 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_MARKUP_get() {
77020   int jresult ;
77021   int result;
77022
77023   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_MARKUP;
77024   jresult = (int)result;
77025   return jresult;
77026 }
77027
77028
77029 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_COLOR_get() {
77030   int jresult ;
77031   int result;
77032
77033   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_COLOR;
77034   jresult = (int)result;
77035   return jresult;
77036 }
77037
77038
77039 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_FAMILY_get() {
77040   int jresult ;
77041   int result;
77042
77043   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_FAMILY;
77044   jresult = (int)result;
77045   return jresult;
77046 }
77047
77048
77049 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_STYLE_get() {
77050   int jresult ;
77051   int result;
77052
77053   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_STYLE;
77054   jresult = (int)result;
77055   return jresult;
77056 }
77057
77058
77059 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_POINT_SIZE_get() {
77060   int jresult ;
77061   int result;
77062
77063   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_POINT_SIZE;
77064   jresult = (int)result;
77065   return jresult;
77066 }
77067
77068
77069 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_LINE_SPACING_get() {
77070   int jresult ;
77071   int result;
77072
77073   result = (int)Dali::Toolkit::TextEditor::Property::LINE_SPACING;
77074   jresult = (int)result;
77075   return jresult;
77076 }
77077
77078
77079 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_LINE_SPACING_get() {
77080   int jresult ;
77081   int result;
77082
77083   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_LINE_SPACING;
77084   jresult = (int)result;
77085   return jresult;
77086 }
77087
77088
77089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_UNDERLINE_get() {
77090   int jresult ;
77091   int result;
77092
77093   result = (int)Dali::Toolkit::TextEditor::Property::UNDERLINE;
77094   jresult = (int)result;
77095   return jresult;
77096 }
77097
77098
77099 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_UNDERLINE_get() {
77100   int jresult ;
77101   int result;
77102
77103   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_UNDERLINE;
77104   jresult = (int)result;
77105   return jresult;
77106 }
77107
77108
77109 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SHADOW_get() {
77110   int jresult ;
77111   int result;
77112
77113   result = (int)Dali::Toolkit::TextEditor::Property::SHADOW;
77114   jresult = (int)result;
77115   return jresult;
77116 }
77117
77118
77119 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_SHADOW_get() {
77120   int jresult ;
77121   int result;
77122
77123   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_SHADOW;
77124   jresult = (int)result;
77125   return jresult;
77126 }
77127
77128
77129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_EMBOSS_get() {
77130   int jresult ;
77131   int result;
77132
77133   result = (int)Dali::Toolkit::TextEditor::Property::EMBOSS;
77134   jresult = (int)result;
77135   return jresult;
77136 }
77137
77138
77139 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_EMBOSS_get() {
77140   int jresult ;
77141   int result;
77142
77143   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_EMBOSS;
77144   jresult = (int)result;
77145   return jresult;
77146 }
77147
77148
77149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_OUTLINE_get() {
77150   int jresult ;
77151   int result;
77152
77153   result = (int)Dali::Toolkit::TextEditor::Property::OUTLINE;
77154   jresult = (int)result;
77155   return jresult;
77156 }
77157
77158
77159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_OUTLINE_get() {
77160   int jresult ;
77161   int result;
77162
77163   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_OUTLINE;
77164   jresult = (int)result;
77165   return jresult;
77166 }
77167
77168
77169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_Property() {
77170   void * jresult ;
77171   Dali::Toolkit::TextEditor::Property *result = 0 ;
77172
77173   {
77174     try {
77175       result = (Dali::Toolkit::TextEditor::Property *)new Dali::Toolkit::TextEditor::Property();
77176     } catch (std::out_of_range& e) {
77177       {
77178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77179       };
77180     } catch (std::exception& e) {
77181       {
77182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77183       };
77184     } catch (...) {
77185       {
77186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77187       };
77188     }
77189   }
77190   jresult = (void *)result;
77191   return jresult;
77192 }
77193
77194
77195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_Property(void * jarg1) {
77196   Dali::Toolkit::TextEditor::Property *arg1 = (Dali::Toolkit::TextEditor::Property *) 0 ;
77197
77198   arg1 = (Dali::Toolkit::TextEditor::Property *)jarg1;
77199   {
77200     try {
77201       delete arg1;
77202     } catch (std::out_of_range& e) {
77203       {
77204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77205       };
77206     } catch (std::exception& e) {
77207       {
77208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77209       };
77210     } catch (...) {
77211       {
77212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77213       };
77214     }
77215   }
77216 }
77217
77218
77219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_InputStyle() {
77220   void * jresult ;
77221   Dali::Toolkit::TextEditor::InputStyle *result = 0 ;
77222
77223   {
77224     try {
77225       result = (Dali::Toolkit::TextEditor::InputStyle *)new Dali::Toolkit::TextEditor::InputStyle();
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 = (void *)result;
77241   return jresult;
77242 }
77243
77244
77245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_InputStyle(void * jarg1) {
77246   Dali::Toolkit::TextEditor::InputStyle *arg1 = (Dali::Toolkit::TextEditor::InputStyle *) 0 ;
77247
77248   arg1 = (Dali::Toolkit::TextEditor::InputStyle *)jarg1;
77249   {
77250     try {
77251       delete arg1;
77252     } catch (std::out_of_range& e) {
77253       {
77254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77255       };
77256     } catch (std::exception& e) {
77257       {
77258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77259       };
77260     } catch (...) {
77261       {
77262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77263       };
77264     }
77265   }
77266 }
77267
77268
77269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_New() {
77270   void * jresult ;
77271   Dali::Toolkit::TextEditor result;
77272
77273   {
77274     try {
77275       result = Dali::Toolkit::TextEditor::New();
77276     } catch (std::out_of_range& e) {
77277       {
77278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77279       };
77280     } catch (std::exception& e) {
77281       {
77282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77283       };
77284     } catch (...) {
77285       {
77286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77287       };
77288     }
77289   }
77290   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
77291   return jresult;
77292 }
77293
77294
77295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_0() {
77296   void * jresult ;
77297   Dali::Toolkit::TextEditor *result = 0 ;
77298
77299   {
77300     try {
77301       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor();
77302     } catch (std::out_of_range& e) {
77303       {
77304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77305       };
77306     } catch (std::exception& e) {
77307       {
77308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77309       };
77310     } catch (...) {
77311       {
77312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77313       };
77314     }
77315   }
77316   jresult = (void *)result;
77317   return jresult;
77318 }
77319
77320
77321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_1(void * jarg1) {
77322   void * jresult ;
77323   Dali::Toolkit::TextEditor *arg1 = 0 ;
77324   Dali::Toolkit::TextEditor *result = 0 ;
77325
77326   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77327   if (!arg1) {
77328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
77329     return 0;
77330   }
77331   {
77332     try {
77333       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor((Dali::Toolkit::TextEditor const &)*arg1);
77334     } catch (std::out_of_range& e) {
77335       {
77336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77337       };
77338     } catch (std::exception& e) {
77339       {
77340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77341       };
77342     } catch (...) {
77343       {
77344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77345       };
77346     }
77347   }
77348   jresult = (void *)result;
77349   return jresult;
77350 }
77351
77352
77353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_Assign(void * jarg1, void * jarg2) {
77354   void * jresult ;
77355   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77356   Dali::Toolkit::TextEditor *arg2 = 0 ;
77357   Dali::Toolkit::TextEditor *result = 0 ;
77358
77359   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77360   arg2 = (Dali::Toolkit::TextEditor *)jarg2;
77361   if (!arg2) {
77362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
77363     return 0;
77364   }
77365   {
77366     try {
77367       result = (Dali::Toolkit::TextEditor *) &(arg1)->operator =((Dali::Toolkit::TextEditor const &)*arg2);
77368     } catch (std::out_of_range& e) {
77369       {
77370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77371       };
77372     } catch (std::exception& e) {
77373       {
77374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77375       };
77376     } catch (...) {
77377       {
77378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77379       };
77380     }
77381   }
77382   jresult = (void *)result;
77383   return jresult;
77384 }
77385
77386
77387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor(void * jarg1) {
77388   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77389
77390   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77391   {
77392     try {
77393       delete arg1;
77394     } catch (std::out_of_range& e) {
77395       {
77396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77397       };
77398     } catch (std::exception& e) {
77399       {
77400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77401       };
77402     } catch (...) {
77403       {
77404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77405       };
77406     }
77407   }
77408 }
77409
77410
77411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_DownCast(void * jarg1) {
77412   void * jresult ;
77413   Dali::BaseHandle arg1 ;
77414   Dali::BaseHandle *argp1 ;
77415   Dali::Toolkit::TextEditor result;
77416
77417   argp1 = (Dali::BaseHandle *)jarg1;
77418   if (!argp1) {
77419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77420     return 0;
77421   }
77422   arg1 = *argp1;
77423   {
77424     try {
77425       result = Dali::Toolkit::TextEditor::DownCast(arg1);
77426     } catch (std::out_of_range& e) {
77427       {
77428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77429       };
77430     } catch (std::exception& e) {
77431       {
77432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77433       };
77434     } catch (...) {
77435       {
77436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77437       };
77438     }
77439   }
77440   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
77441   return jresult;
77442 }
77443
77444
77445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_TextChangedSignal(void * jarg1) {
77446   void * jresult ;
77447   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77448   Dali::Toolkit::TextEditor::TextChangedSignalType *result = 0 ;
77449
77450   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77451   {
77452     try {
77453       result = (Dali::Toolkit::TextEditor::TextChangedSignalType *) &(arg1)->TextChangedSignal();
77454     } catch (std::out_of_range& e) {
77455       {
77456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77457       };
77458     } catch (std::exception& e) {
77459       {
77460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77461       };
77462     } catch (...) {
77463       {
77464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77465       };
77466     }
77467   }
77468   jresult = (void *)result;
77469   return jresult;
77470 }
77471
77472
77473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_InputStyleChangedSignal(void * jarg1) {
77474   void * jresult ;
77475   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77476   Dali::Toolkit::TextEditor::InputStyleChangedSignalType *result = 0 ;
77477
77478   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77479   {
77480     try {
77481       result = (Dali::Toolkit::TextEditor::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
77482     } catch (std::out_of_range& e) {
77483       {
77484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77485       };
77486     } catch (std::exception& e) {
77487       {
77488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77489       };
77490     } catch (...) {
77491       {
77492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77493       };
77494     }
77495   }
77496   jresult = (void *)result;
77497   return jresult;
77498 }
77499
77500
77501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_RENDERING_BACKEND_get() {
77502   int jresult ;
77503   int result;
77504
77505   result = (int)Dali::Toolkit::TextField::Property::RENDERING_BACKEND;
77506   jresult = (int)result;
77507   return jresult;
77508 }
77509
77510
77511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_get() {
77512   int jresult ;
77513   int result;
77514
77515   result = (int)Dali::Toolkit::TextField::Property::TEXT;
77516   jresult = (int)result;
77517   return jresult;
77518 }
77519
77520
77521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_get() {
77522   int jresult ;
77523   int result;
77524
77525   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT;
77526   jresult = (int)result;
77527   return jresult;
77528 }
77529
77530
77531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_FOCUSED_get() {
77532   int jresult ;
77533   int result;
77534
77535   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_FOCUSED;
77536   jresult = (int)result;
77537   return jresult;
77538 }
77539
77540
77541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_FAMILY_get() {
77542   int jresult ;
77543   int result;
77544
77545   result = (int)Dali::Toolkit::TextField::Property::FONT_FAMILY;
77546   jresult = (int)result;
77547   return jresult;
77548 }
77549
77550
77551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_STYLE_get() {
77552   int jresult ;
77553   int result;
77554
77555   result = (int)Dali::Toolkit::TextField::Property::FONT_STYLE;
77556   jresult = (int)result;
77557   return jresult;
77558 }
77559
77560
77561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_POINT_SIZE_get() {
77562   int jresult ;
77563   int result;
77564
77565   result = (int)Dali::Toolkit::TextField::Property::POINT_SIZE;
77566   jresult = (int)result;
77567   return jresult;
77568 }
77569
77570
77571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_MAX_LENGTH_get() {
77572   int jresult ;
77573   int result;
77574
77575   result = (int)Dali::Toolkit::TextField::Property::MAX_LENGTH;
77576   jresult = (int)result;
77577   return jresult;
77578 }
77579
77580
77581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EXCEED_POLICY_get() {
77582   int jresult ;
77583   int result;
77584
77585   result = (int)Dali::Toolkit::TextField::Property::EXCEED_POLICY;
77586   jresult = (int)result;
77587   return jresult;
77588 }
77589
77590
77591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_HORIZONTAL_ALIGNMENT_get() {
77592   int jresult ;
77593   int result;
77594
77595   result = (int)Dali::Toolkit::TextField::Property::HORIZONTAL_ALIGNMENT;
77596   jresult = (int)result;
77597   return jresult;
77598 }
77599
77600
77601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_VERTICAL_ALIGNMENT_get() {
77602   int jresult ;
77603   int result;
77604
77605   result = (int)Dali::Toolkit::TextField::Property::VERTICAL_ALIGNMENT;
77606   jresult = (int)result;
77607   return jresult;
77608 }
77609
77610
77611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_COLOR_get() {
77612   int jresult ;
77613   int result;
77614
77615   result = (int)Dali::Toolkit::TextField::Property::TEXT_COLOR;
77616   jresult = (int)result;
77617   return jresult;
77618 }
77619
77620
77621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_COLOR_get() {
77622   int jresult ;
77623   int result;
77624
77625   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_COLOR;
77626   jresult = (int)result;
77627   return jresult;
77628 }
77629
77630
77631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_OFFSET_get() {
77632   int jresult ;
77633   int result;
77634
77635   result = (int)Dali::Toolkit::TextField::Property::SHADOW_OFFSET;
77636   jresult = (int)result;
77637   return jresult;
77638 }
77639
77640
77641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_COLOR_get() {
77642   int jresult ;
77643   int result;
77644
77645   result = (int)Dali::Toolkit::TextField::Property::SHADOW_COLOR;
77646   jresult = (int)result;
77647   return jresult;
77648 }
77649
77650
77651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PRIMARY_CURSOR_COLOR_get() {
77652   int jresult ;
77653   int result;
77654
77655   result = (int)Dali::Toolkit::TextField::Property::PRIMARY_CURSOR_COLOR;
77656   jresult = (int)result;
77657   return jresult;
77658 }
77659
77660
77661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SECONDARY_CURSOR_COLOR_get() {
77662   int jresult ;
77663   int result;
77664
77665   result = (int)Dali::Toolkit::TextField::Property::SECONDARY_CURSOR_COLOR;
77666   jresult = (int)result;
77667   return jresult;
77668 }
77669
77670
77671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_CURSOR_BLINK_get() {
77672   int jresult ;
77673   int result;
77674
77675   result = (int)Dali::Toolkit::TextField::Property::ENABLE_CURSOR_BLINK;
77676   jresult = (int)result;
77677   return jresult;
77678 }
77679
77680
77681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_INTERVAL_get() {
77682   int jresult ;
77683   int result;
77684
77685   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_INTERVAL;
77686   jresult = (int)result;
77687   return jresult;
77688 }
77689
77690
77691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_DURATION_get() {
77692   int jresult ;
77693   int result;
77694
77695   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_DURATION;
77696   jresult = (int)result;
77697   return jresult;
77698 }
77699
77700
77701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_WIDTH_get() {
77702   int jresult ;
77703   int result;
77704
77705   result = (int)Dali::Toolkit::TextField::Property::CURSOR_WIDTH;
77706   jresult = (int)result;
77707   return jresult;
77708 }
77709
77710
77711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_IMAGE_get() {
77712   int jresult ;
77713   int result;
77714
77715   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_IMAGE;
77716   jresult = (int)result;
77717   return jresult;
77718 }
77719
77720
77721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
77722   int jresult ;
77723   int result;
77724
77725   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_PRESSED_IMAGE;
77726   jresult = (int)result;
77727   return jresult;
77728 }
77729
77730
77731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_THRESHOLD_get() {
77732   int jresult ;
77733   int result;
77734
77735   result = (int)Dali::Toolkit::TextField::Property::SCROLL_THRESHOLD;
77736   jresult = (int)result;
77737   return jresult;
77738 }
77739
77740
77741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_SPEED_get() {
77742   int jresult ;
77743   int result;
77744
77745   result = (int)Dali::Toolkit::TextField::Property::SCROLL_SPEED;
77746   jresult = (int)result;
77747   return jresult;
77748 }
77749
77750
77751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
77752   int jresult ;
77753   int result;
77754
77755   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_LEFT;
77756   jresult = (int)result;
77757   return jresult;
77758 }
77759
77760
77761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
77762   int jresult ;
77763   int result;
77764
77765   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT;
77766   jresult = (int)result;
77767   return jresult;
77768 }
77769
77770
77771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
77772   int jresult ;
77773   int result;
77774
77775   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
77776   jresult = (int)result;
77777   return jresult;
77778 }
77779
77780
77781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
77782   int jresult ;
77783   int result;
77784
77785   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
77786   jresult = (int)result;
77787   return jresult;
77788 }
77789
77790
77791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
77792   int jresult ;
77793   int result;
77794
77795   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
77796   jresult = (int)result;
77797   return jresult;
77798 }
77799
77800
77801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
77802   int jresult ;
77803   int result;
77804
77805   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
77806   jresult = (int)result;
77807   return jresult;
77808 }
77809
77810
77811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HIGHLIGHT_COLOR_get() {
77812   int jresult ;
77813   int result;
77814
77815   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HIGHLIGHT_COLOR;
77816   jresult = (int)result;
77817   return jresult;
77818 }
77819
77820
77821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_DECORATION_BOUNDING_BOX_get() {
77822   int jresult ;
77823   int result;
77824
77825   result = (int)Dali::Toolkit::TextField::Property::DECORATION_BOUNDING_BOX;
77826   jresult = (int)result;
77827   return jresult;
77828 }
77829
77830
77831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_METHOD_SETTINGS_get() {
77832   int jresult ;
77833   int result;
77834
77835   result = (int)Dali::Toolkit::TextField::Property::INPUT_METHOD_SETTINGS;
77836   jresult = (int)result;
77837   return jresult;
77838 }
77839
77840
77841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_COLOR_get() {
77842   int jresult ;
77843   int result;
77844
77845   result = (int)Dali::Toolkit::TextField::Property::INPUT_COLOR;
77846   jresult = (int)result;
77847   return jresult;
77848 }
77849
77850
77851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_MARKUP_get() {
77852   int jresult ;
77853   int result;
77854
77855   result = (int)Dali::Toolkit::TextField::Property::ENABLE_MARKUP;
77856   jresult = (int)result;
77857   return jresult;
77858 }
77859
77860
77861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_FAMILY_get() {
77862   int jresult ;
77863   int result;
77864
77865   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_FAMILY;
77866   jresult = (int)result;
77867   return jresult;
77868 }
77869
77870
77871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_STYLE_get() {
77872   int jresult ;
77873   int result;
77874
77875   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_STYLE;
77876   jresult = (int)result;
77877   return jresult;
77878 }
77879
77880
77881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_POINT_SIZE_get() {
77882   int jresult ;
77883   int result;
77884
77885   result = (int)Dali::Toolkit::TextField::Property::INPUT_POINT_SIZE;
77886   jresult = (int)result;
77887   return jresult;
77888 }
77889
77890
77891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_UNDERLINE_get() {
77892   int jresult ;
77893   int result;
77894
77895   result = (int)Dali::Toolkit::TextField::Property::UNDERLINE;
77896   jresult = (int)result;
77897   return jresult;
77898 }
77899
77900
77901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_UNDERLINE_get() {
77902   int jresult ;
77903   int result;
77904
77905   result = (int)Dali::Toolkit::TextField::Property::INPUT_UNDERLINE;
77906   jresult = (int)result;
77907   return jresult;
77908 }
77909
77910
77911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_get() {
77912   int jresult ;
77913   int result;
77914
77915   result = (int)Dali::Toolkit::TextField::Property::SHADOW;
77916   jresult = (int)result;
77917   return jresult;
77918 }
77919
77920
77921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_SHADOW_get() {
77922   int jresult ;
77923   int result;
77924
77925   result = (int)Dali::Toolkit::TextField::Property::INPUT_SHADOW;
77926   jresult = (int)result;
77927   return jresult;
77928 }
77929
77930
77931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EMBOSS_get() {
77932   int jresult ;
77933   int result;
77934
77935   result = (int)Dali::Toolkit::TextField::Property::EMBOSS;
77936   jresult = (int)result;
77937   return jresult;
77938 }
77939
77940
77941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_EMBOSS_get() {
77942   int jresult ;
77943   int result;
77944
77945   result = (int)Dali::Toolkit::TextField::Property::INPUT_EMBOSS;
77946   jresult = (int)result;
77947   return jresult;
77948 }
77949
77950
77951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_OUTLINE_get() {
77952   int jresult ;
77953   int result;
77954
77955   result = (int)Dali::Toolkit::TextField::Property::OUTLINE;
77956   jresult = (int)result;
77957   return jresult;
77958 }
77959
77960
77961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_OUTLINE_get() {
77962   int jresult ;
77963   int result;
77964
77965   result = (int)Dali::Toolkit::TextField::Property::INPUT_OUTLINE;
77966   jresult = (int)result;
77967   return jresult;
77968 }
77969
77970
77971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_Property() {
77972   void * jresult ;
77973   Dali::Toolkit::TextField::Property *result = 0 ;
77974
77975   {
77976     try {
77977       result = (Dali::Toolkit::TextField::Property *)new Dali::Toolkit::TextField::Property();
77978     } catch (std::out_of_range& e) {
77979       {
77980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77981       };
77982     } catch (std::exception& e) {
77983       {
77984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77985       };
77986     } catch (...) {
77987       {
77988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77989       };
77990     }
77991   }
77992   jresult = (void *)result;
77993   return jresult;
77994 }
77995
77996
77997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_Property(void * jarg1) {
77998   Dali::Toolkit::TextField::Property *arg1 = (Dali::Toolkit::TextField::Property *) 0 ;
77999
78000   arg1 = (Dali::Toolkit::TextField::Property *)jarg1;
78001   {
78002     try {
78003       delete arg1;
78004     } catch (std::out_of_range& e) {
78005       {
78006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78007       };
78008     } catch (std::exception& e) {
78009       {
78010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78011       };
78012     } catch (...) {
78013       {
78014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78015       };
78016     }
78017   }
78018 }
78019
78020
78021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_InputStyle() {
78022   void * jresult ;
78023   Dali::Toolkit::TextField::InputStyle *result = 0 ;
78024
78025   {
78026     try {
78027       result = (Dali::Toolkit::TextField::InputStyle *)new Dali::Toolkit::TextField::InputStyle();
78028     } catch (std::out_of_range& e) {
78029       {
78030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78031       };
78032     } catch (std::exception& e) {
78033       {
78034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78035       };
78036     } catch (...) {
78037       {
78038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78039       };
78040     }
78041   }
78042   jresult = (void *)result;
78043   return jresult;
78044 }
78045
78046
78047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_InputStyle(void * jarg1) {
78048   Dali::Toolkit::TextField::InputStyle *arg1 = (Dali::Toolkit::TextField::InputStyle *) 0 ;
78049
78050   arg1 = (Dali::Toolkit::TextField::InputStyle *)jarg1;
78051   {
78052     try {
78053       delete arg1;
78054     } catch (std::out_of_range& e) {
78055       {
78056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78057       };
78058     } catch (std::exception& e) {
78059       {
78060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78061       };
78062     } catch (...) {
78063       {
78064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78065       };
78066     }
78067   }
78068 }
78069
78070
78071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_New() {
78072   void * jresult ;
78073   Dali::Toolkit::TextField result;
78074
78075   {
78076     try {
78077       result = Dali::Toolkit::TextField::New();
78078     } catch (std::out_of_range& e) {
78079       {
78080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78081       };
78082     } catch (std::exception& e) {
78083       {
78084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78085       };
78086     } catch (...) {
78087       {
78088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78089       };
78090     }
78091   }
78092   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
78093   return jresult;
78094 }
78095
78096
78097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_0() {
78098   void * jresult ;
78099   Dali::Toolkit::TextField *result = 0 ;
78100
78101   {
78102     try {
78103       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField();
78104     } catch (std::out_of_range& e) {
78105       {
78106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78107       };
78108     } catch (std::exception& e) {
78109       {
78110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78111       };
78112     } catch (...) {
78113       {
78114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78115       };
78116     }
78117   }
78118   jresult = (void *)result;
78119   return jresult;
78120 }
78121
78122
78123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_1(void * jarg1) {
78124   void * jresult ;
78125   Dali::Toolkit::TextField *arg1 = 0 ;
78126   Dali::Toolkit::TextField *result = 0 ;
78127
78128   arg1 = (Dali::Toolkit::TextField *)jarg1;
78129   if (!arg1) {
78130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
78131     return 0;
78132   }
78133   {
78134     try {
78135       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField((Dali::Toolkit::TextField const &)*arg1);
78136     } catch (std::out_of_range& e) {
78137       {
78138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78139       };
78140     } catch (std::exception& e) {
78141       {
78142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78143       };
78144     } catch (...) {
78145       {
78146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78147       };
78148     }
78149   }
78150   jresult = (void *)result;
78151   return jresult;
78152 }
78153
78154
78155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_Assign(void * jarg1, void * jarg2) {
78156   void * jresult ;
78157   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78158   Dali::Toolkit::TextField *arg2 = 0 ;
78159   Dali::Toolkit::TextField *result = 0 ;
78160
78161   arg1 = (Dali::Toolkit::TextField *)jarg1;
78162   arg2 = (Dali::Toolkit::TextField *)jarg2;
78163   if (!arg2) {
78164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
78165     return 0;
78166   }
78167   {
78168     try {
78169       result = (Dali::Toolkit::TextField *) &(arg1)->operator =((Dali::Toolkit::TextField const &)*arg2);
78170     } catch (std::out_of_range& e) {
78171       {
78172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78173       };
78174     } catch (std::exception& e) {
78175       {
78176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78177       };
78178     } catch (...) {
78179       {
78180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78181       };
78182     }
78183   }
78184   jresult = (void *)result;
78185   return jresult;
78186 }
78187
78188
78189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField(void * jarg1) {
78190   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78191
78192   arg1 = (Dali::Toolkit::TextField *)jarg1;
78193   {
78194     try {
78195       delete arg1;
78196     } catch (std::out_of_range& e) {
78197       {
78198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78199       };
78200     } catch (std::exception& e) {
78201       {
78202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78203       };
78204     } catch (...) {
78205       {
78206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78207       };
78208     }
78209   }
78210 }
78211
78212
78213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_DownCast(void * jarg1) {
78214   void * jresult ;
78215   Dali::BaseHandle arg1 ;
78216   Dali::BaseHandle *argp1 ;
78217   Dali::Toolkit::TextField result;
78218
78219   argp1 = (Dali::BaseHandle *)jarg1;
78220   if (!argp1) {
78221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78222     return 0;
78223   }
78224   arg1 = *argp1;
78225   {
78226     try {
78227       result = Dali::Toolkit::TextField::DownCast(arg1);
78228     } catch (std::out_of_range& e) {
78229       {
78230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78231       };
78232     } catch (std::exception& e) {
78233       {
78234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78235       };
78236     } catch (...) {
78237       {
78238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78239       };
78240     }
78241   }
78242   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
78243   return jresult;
78244 }
78245
78246
78247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_TextChangedSignal(void * jarg1) {
78248   void * jresult ;
78249   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78250   Dali::Toolkit::TextField::TextChangedSignalType *result = 0 ;
78251
78252   arg1 = (Dali::Toolkit::TextField *)jarg1;
78253   {
78254     try {
78255       result = (Dali::Toolkit::TextField::TextChangedSignalType *) &(arg1)->TextChangedSignal();
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_TextField_MaxLengthReachedSignal(void * jarg1) {
78276   void * jresult ;
78277   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78278   Dali::Toolkit::TextField::MaxLengthReachedSignalType *result = 0 ;
78279
78280   arg1 = (Dali::Toolkit::TextField *)jarg1;
78281   {
78282     try {
78283       result = (Dali::Toolkit::TextField::MaxLengthReachedSignalType *) &(arg1)->MaxLengthReachedSignal();
78284     } catch (std::out_of_range& e) {
78285       {
78286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78287       };
78288     } catch (std::exception& e) {
78289       {
78290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78291       };
78292     } catch (...) {
78293       {
78294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78295       };
78296     }
78297   }
78298   jresult = (void *)result;
78299   return jresult;
78300 }
78301
78302
78303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_InputStyleChangedSignal(void * jarg1) {
78304   void * jresult ;
78305   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78306   Dali::Toolkit::TextField::InputStyleChangedSignalType *result = 0 ;
78307
78308   arg1 = (Dali::Toolkit::TextField *)jarg1;
78309   {
78310     try {
78311       result = (Dali::Toolkit::TextField::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
78312     } catch (std::out_of_range& e) {
78313       {
78314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78315       };
78316     } catch (std::exception& e) {
78317       {
78318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78319       };
78320     } catch (...) {
78321       {
78322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78323       };
78324     }
78325   }
78326   jresult = (void *)result;
78327   return jresult;
78328 }
78329
78330
78331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
78332   int jresult ;
78333   int result;
78334
78335   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
78336   jresult = (int)result;
78337   return jresult;
78338 }
78339
78340
78341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
78342   int jresult ;
78343   int result;
78344
78345   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
78346   jresult = (int)result;
78347   return jresult;
78348 }
78349
78350
78351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
78352   int jresult ;
78353   int result;
78354
78355   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
78356   jresult = (int)result;
78357   return jresult;
78358 }
78359
78360
78361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
78362   int jresult ;
78363   int result;
78364
78365   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
78366   jresult = (int)result;
78367   return jresult;
78368 }
78369
78370
78371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
78372   int jresult ;
78373   int result;
78374
78375   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
78376   jresult = (int)result;
78377   return jresult;
78378 }
78379
78380
78381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
78382   int jresult ;
78383   int result;
78384
78385   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
78386   jresult = (int)result;
78387   return jresult;
78388 }
78389
78390
78391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
78392   int jresult ;
78393   int result;
78394
78395   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
78396   jresult = (int)result;
78397   return jresult;
78398 }
78399
78400
78401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
78402   int jresult ;
78403   int result;
78404
78405   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
78406   jresult = (int)result;
78407   return jresult;
78408 }
78409
78410
78411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
78412   int jresult ;
78413   int result;
78414
78415   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
78416   jresult = (int)result;
78417   return jresult;
78418 }
78419
78420
78421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
78422   int jresult ;
78423   int result;
78424
78425   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
78426   jresult = (int)result;
78427   return jresult;
78428 }
78429
78430
78431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
78432   int jresult ;
78433   int result;
78434
78435   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
78436   jresult = (int)result;
78437   return jresult;
78438 }
78439
78440
78441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
78442   int jresult ;
78443   int result;
78444
78445   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
78446   jresult = (int)result;
78447   return jresult;
78448 }
78449
78450
78451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
78452   int jresult ;
78453   int result;
78454
78455   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
78456   jresult = (int)result;
78457   return jresult;
78458 }
78459
78460
78461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
78462   int jresult ;
78463   int result;
78464
78465   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
78466   jresult = (int)result;
78467   return jresult;
78468 }
78469
78470
78471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
78472   int jresult ;
78473   int result;
78474
78475   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
78476   jresult = (int)result;
78477   return jresult;
78478 }
78479
78480
78481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
78482   int jresult ;
78483   int result;
78484
78485   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
78486   jresult = (int)result;
78487   return jresult;
78488 }
78489
78490
78491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
78492   int jresult ;
78493   int result;
78494
78495   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
78496   jresult = (int)result;
78497   return jresult;
78498 }
78499
78500
78501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
78502   int jresult ;
78503   int result;
78504
78505   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
78506   jresult = (int)result;
78507   return jresult;
78508 }
78509
78510
78511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
78512   int jresult ;
78513   int result;
78514
78515   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
78516   jresult = (int)result;
78517   return jresult;
78518 }
78519
78520
78521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
78522   int jresult ;
78523   int result;
78524
78525   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
78526   jresult = (int)result;
78527   return jresult;
78528 }
78529
78530
78531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
78532   int jresult ;
78533   int result;
78534
78535   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
78536   jresult = (int)result;
78537   return jresult;
78538 }
78539
78540
78541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
78542   int jresult ;
78543   int result;
78544
78545   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
78546   jresult = (int)result;
78547   return jresult;
78548 }
78549
78550
78551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
78552   int jresult ;
78553   int result;
78554
78555   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
78556   jresult = (int)result;
78557   return jresult;
78558 }
78559
78560
78561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
78562   int jresult ;
78563   int result;
78564
78565   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
78566   jresult = (int)result;
78567   return jresult;
78568 }
78569
78570
78571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
78572   void * jresult ;
78573   Dali::Toolkit::TextLabel::Property *result = 0 ;
78574
78575   {
78576     try {
78577       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
78578     } catch (std::out_of_range& e) {
78579       {
78580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78581       };
78582     } catch (std::exception& e) {
78583       {
78584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78585       };
78586     } catch (...) {
78587       {
78588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78589       };
78590     }
78591   }
78592   jresult = (void *)result;
78593   return jresult;
78594 }
78595
78596
78597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
78598   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
78599
78600   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
78601   {
78602     try {
78603       delete arg1;
78604     } catch (std::out_of_range& e) {
78605       {
78606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78607       };
78608     } catch (std::exception& e) {
78609       {
78610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78611       };
78612     } catch (...) {
78613       {
78614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78615       };
78616     }
78617   }
78618 }
78619
78620
78621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
78622   void * jresult ;
78623   Dali::Toolkit::TextLabel result;
78624
78625   {
78626     try {
78627       result = Dali::Toolkit::TextLabel::New();
78628     } catch (std::out_of_range& e) {
78629       {
78630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78631       };
78632     } catch (std::exception& e) {
78633       {
78634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78635       };
78636     } catch (...) {
78637       {
78638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78639       };
78640     }
78641   }
78642   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78643   return jresult;
78644 }
78645
78646
78647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
78648   void * jresult ;
78649   std::string *arg1 = 0 ;
78650   Dali::Toolkit::TextLabel result;
78651
78652   if (!jarg1) {
78653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78654     return 0;
78655   }
78656   std::string arg1_str(jarg1);
78657   arg1 = &arg1_str;
78658   {
78659     try {
78660       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
78661     } catch (std::out_of_range& e) {
78662       {
78663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78664       };
78665     } catch (std::exception& e) {
78666       {
78667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78668       };
78669     } catch (...) {
78670       {
78671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78672       };
78673     }
78674   }
78675   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78676
78677   //argout typemap for const std::string&
78678
78679   return jresult;
78680 }
78681
78682
78683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
78684   void * jresult ;
78685   Dali::Toolkit::TextLabel *result = 0 ;
78686
78687   {
78688     try {
78689       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
78690     } catch (std::out_of_range& e) {
78691       {
78692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78693       };
78694     } catch (std::exception& e) {
78695       {
78696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78697       };
78698     } catch (...) {
78699       {
78700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78701       };
78702     }
78703   }
78704   jresult = (void *)result;
78705   return jresult;
78706 }
78707
78708
78709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
78710   void * jresult ;
78711   Dali::Toolkit::TextLabel *arg1 = 0 ;
78712   Dali::Toolkit::TextLabel *result = 0 ;
78713
78714   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78715   if (!arg1) {
78716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78717     return 0;
78718   }
78719   {
78720     try {
78721       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
78722     } catch (std::out_of_range& e) {
78723       {
78724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78725       };
78726     } catch (std::exception& e) {
78727       {
78728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78729       };
78730     } catch (...) {
78731       {
78732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78733       };
78734     }
78735   }
78736   jresult = (void *)result;
78737   return jresult;
78738 }
78739
78740
78741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
78742   void * jresult ;
78743   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78744   Dali::Toolkit::TextLabel *arg2 = 0 ;
78745   Dali::Toolkit::TextLabel *result = 0 ;
78746
78747   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78748   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
78749   if (!arg2) {
78750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78751     return 0;
78752   }
78753   {
78754     try {
78755       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
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_delete_TextLabel(void * jarg1) {
78776   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78777
78778   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78779   {
78780     try {
78781       delete arg1;
78782     } catch (std::out_of_range& e) {
78783       {
78784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78785       };
78786     } catch (std::exception& e) {
78787       {
78788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78789       };
78790     } catch (...) {
78791       {
78792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78793       };
78794     }
78795   }
78796 }
78797
78798
78799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
78800   void * jresult ;
78801   Dali::BaseHandle arg1 ;
78802   Dali::BaseHandle *argp1 ;
78803   Dali::Toolkit::TextLabel result;
78804
78805   argp1 = (Dali::BaseHandle *)jarg1;
78806   if (!argp1) {
78807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78808     return 0;
78809   }
78810   arg1 = *argp1;
78811   {
78812     try {
78813       result = Dali::Toolkit::TextLabel::DownCast(arg1);
78814     } catch (std::out_of_range& e) {
78815       {
78816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78817       };
78818     } catch (std::exception& e) {
78819       {
78820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78821       };
78822     } catch (...) {
78823       {
78824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78825       };
78826     }
78827   }
78828   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78829   return jresult;
78830 }
78831
78832
78833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
78834   void * jresult ;
78835   Dali::Toolkit::AccessibilityManager *result = 0 ;
78836
78837   {
78838     try {
78839       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
78840     } catch (std::out_of_range& e) {
78841       {
78842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78843       };
78844     } catch (std::exception& e) {
78845       {
78846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78847       };
78848     } catch (...) {
78849       {
78850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78851       };
78852     }
78853   }
78854   jresult = (void *)result;
78855   return jresult;
78856 }
78857
78858
78859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
78860   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78861
78862   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78863   {
78864     try {
78865       delete arg1;
78866     } catch (std::out_of_range& e) {
78867       {
78868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78869       };
78870     } catch (std::exception& e) {
78871       {
78872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78873       };
78874     } catch (...) {
78875       {
78876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78877       };
78878     }
78879   }
78880 }
78881
78882
78883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
78884   void * jresult ;
78885   Dali::Toolkit::AccessibilityManager result;
78886
78887   {
78888     try {
78889       result = Dali::Toolkit::AccessibilityManager::Get();
78890     } catch (std::out_of_range& e) {
78891       {
78892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78893       };
78894     } catch (std::exception& e) {
78895       {
78896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78897       };
78898     } catch (...) {
78899       {
78900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78901       };
78902     }
78903   }
78904   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
78905   return jresult;
78906 }
78907
78908
78909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
78910   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78911   Dali::Actor arg2 ;
78912   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
78913   std::string *arg4 = 0 ;
78914   Dali::Actor *argp2 ;
78915
78916   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78917   argp2 = (Dali::Actor *)jarg2;
78918   if (!argp2) {
78919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78920     return ;
78921   }
78922   arg2 = *argp2;
78923   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
78924   if (!jarg4) {
78925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78926     return ;
78927   }
78928   std::string arg4_str(jarg4);
78929   arg4 = &arg4_str;
78930   {
78931     try {
78932       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
78933     } catch (std::out_of_range& e) {
78934       {
78935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78936       };
78937     } catch (std::exception& e) {
78938       {
78939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78940       };
78941     } catch (...) {
78942       {
78943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78944       };
78945     }
78946   }
78947
78948   //argout typemap for const std::string&
78949
78950 }
78951
78952
78953 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
78954   char * jresult ;
78955   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78956   Dali::Actor arg2 ;
78957   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
78958   Dali::Actor *argp2 ;
78959   std::string result;
78960
78961   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78962   argp2 = (Dali::Actor *)jarg2;
78963   if (!argp2) {
78964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78965     return 0;
78966   }
78967   arg2 = *argp2;
78968   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
78969   {
78970     try {
78971       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
78972     } catch (std::out_of_range& e) {
78973       {
78974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78975       };
78976     } catch (std::exception& e) {
78977       {
78978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78979       };
78980     } catch (...) {
78981       {
78982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78983       };
78984     }
78985   }
78986   jresult = SWIG_csharp_string_callback((&result)->c_str());
78987   return jresult;
78988 }
78989
78990
78991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
78992   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78993   Dali::Actor arg2 ;
78994   unsigned int arg3 ;
78995   Dali::Actor *argp2 ;
78996
78997   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78998   argp2 = (Dali::Actor *)jarg2;
78999   if (!argp2) {
79000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79001     return ;
79002   }
79003   arg2 = *argp2;
79004   arg3 = (unsigned int)jarg3;
79005   {
79006     try {
79007       (arg1)->SetFocusOrder(arg2,arg3);
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 unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
79026   unsigned int jresult ;
79027   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79028   Dali::Actor arg2 ;
79029   Dali::Actor *argp2 ;
79030   unsigned int result;
79031
79032   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79033   argp2 = (Dali::Actor *)jarg2;
79034   if (!argp2) {
79035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79036     return 0;
79037   }
79038   arg2 = *argp2;
79039   {
79040     try {
79041       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
79042     } catch (std::out_of_range& e) {
79043       {
79044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79045       };
79046     } catch (std::exception& e) {
79047       {
79048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79049       };
79050     } catch (...) {
79051       {
79052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79053       };
79054     }
79055   }
79056   jresult = result;
79057   return jresult;
79058 }
79059
79060
79061 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
79062   unsigned int jresult ;
79063   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79064   unsigned int result;
79065
79066   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79067   {
79068     try {
79069       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
79070     } catch (std::out_of_range& e) {
79071       {
79072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79073       };
79074     } catch (std::exception& e) {
79075       {
79076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79077       };
79078     } catch (...) {
79079       {
79080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79081       };
79082     }
79083   }
79084   jresult = result;
79085   return jresult;
79086 }
79087
79088
79089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
79090   void * jresult ;
79091   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79092   unsigned int arg2 ;
79093   Dali::Actor result;
79094
79095   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79096   arg2 = (unsigned int)jarg2;
79097   {
79098     try {
79099       result = (arg1)->GetActorByFocusOrder(arg2);
79100     } catch (std::out_of_range& e) {
79101       {
79102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79103       };
79104     } catch (std::exception& e) {
79105       {
79106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79107       };
79108     } catch (...) {
79109       {
79110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79111       };
79112     }
79113   }
79114   jresult = new Dali::Actor((const Dali::Actor &)result);
79115   return jresult;
79116 }
79117
79118
79119 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
79120   unsigned int jresult ;
79121   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79122   Dali::Actor arg2 ;
79123   Dali::Actor *argp2 ;
79124   bool result;
79125
79126   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79127   argp2 = (Dali::Actor *)jarg2;
79128   if (!argp2) {
79129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79130     return 0;
79131   }
79132   arg2 = *argp2;
79133   {
79134     try {
79135       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
79136     } catch (std::out_of_range& e) {
79137       {
79138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79139       };
79140     } catch (std::exception& e) {
79141       {
79142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79143       };
79144     } catch (...) {
79145       {
79146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79147       };
79148     }
79149   }
79150   jresult = result;
79151   return jresult;
79152 }
79153
79154
79155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
79156   void * jresult ;
79157   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79158   Dali::Actor result;
79159
79160   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79161   {
79162     try {
79163       result = (arg1)->GetCurrentFocusActor();
79164     } catch (std::out_of_range& e) {
79165       {
79166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79167       };
79168     } catch (std::exception& e) {
79169       {
79170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79171       };
79172     } catch (...) {
79173       {
79174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79175       };
79176     }
79177   }
79178   jresult = new Dali::Actor((const Dali::Actor &)result);
79179   return jresult;
79180 }
79181
79182
79183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
79184   void * jresult ;
79185   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79186   Dali::Actor result;
79187
79188   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79189   {
79190     try {
79191       result = (arg1)->GetCurrentFocusGroup();
79192     } catch (std::out_of_range& e) {
79193       {
79194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79195       };
79196     } catch (std::exception& e) {
79197       {
79198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79199       };
79200     } catch (...) {
79201       {
79202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79203       };
79204     }
79205   }
79206   jresult = new Dali::Actor((const Dali::Actor &)result);
79207   return jresult;
79208 }
79209
79210
79211 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
79212   unsigned int jresult ;
79213   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79214   unsigned int result;
79215
79216   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79217   {
79218     try {
79219       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
79220     } catch (std::out_of_range& e) {
79221       {
79222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79223       };
79224     } catch (std::exception& e) {
79225       {
79226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79227       };
79228     } catch (...) {
79229       {
79230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79231       };
79232     }
79233   }
79234   jresult = result;
79235   return jresult;
79236 }
79237
79238
79239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
79240   unsigned int jresult ;
79241   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79242   bool result;
79243
79244   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79245   {
79246     try {
79247       result = (bool)(arg1)->MoveFocusForward();
79248     } catch (std::out_of_range& e) {
79249       {
79250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79251       };
79252     } catch (std::exception& e) {
79253       {
79254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79255       };
79256     } catch (...) {
79257       {
79258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79259       };
79260     }
79261   }
79262   jresult = result;
79263   return jresult;
79264 }
79265
79266
79267 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
79268   unsigned int jresult ;
79269   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79270   bool result;
79271
79272   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79273   {
79274     try {
79275       result = (bool)(arg1)->MoveFocusBackward();
79276     } catch (std::out_of_range& e) {
79277       {
79278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79279       };
79280     } catch (std::exception& e) {
79281       {
79282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79283       };
79284     } catch (...) {
79285       {
79286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79287       };
79288     }
79289   }
79290   jresult = result;
79291   return jresult;
79292 }
79293
79294
79295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
79296   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79297
79298   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79299   {
79300     try {
79301       (arg1)->ClearFocus();
79302     } catch (std::out_of_range& e) {
79303       {
79304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79305       };
79306     } catch (std::exception& e) {
79307       {
79308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79309       };
79310     } catch (...) {
79311       {
79312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79313       };
79314     }
79315   }
79316 }
79317
79318
79319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
79320   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79321
79322   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79323   {
79324     try {
79325       (arg1)->Reset();
79326     } catch (std::out_of_range& e) {
79327       {
79328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79329       };
79330     } catch (std::exception& e) {
79331       {
79332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79333       };
79334     } catch (...) {
79335       {
79336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79337       };
79338     }
79339   }
79340 }
79341
79342
79343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
79344   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79345   Dali::Actor arg2 ;
79346   bool arg3 ;
79347   Dali::Actor *argp2 ;
79348
79349   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79350   argp2 = (Dali::Actor *)jarg2;
79351   if (!argp2) {
79352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79353     return ;
79354   }
79355   arg2 = *argp2;
79356   arg3 = jarg3 ? true : false;
79357   {
79358     try {
79359       (arg1)->SetFocusGroup(arg2,arg3);
79360     } catch (std::out_of_range& e) {
79361       {
79362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79363       };
79364     } catch (std::exception& e) {
79365       {
79366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79367       };
79368     } catch (...) {
79369       {
79370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79371       };
79372     }
79373   }
79374 }
79375
79376
79377 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
79378   unsigned int jresult ;
79379   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79380   Dali::Actor arg2 ;
79381   Dali::Actor *argp2 ;
79382   bool result;
79383
79384   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79385   argp2 = (Dali::Actor *)jarg2;
79386   if (!argp2) {
79387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79388     return 0;
79389   }
79390   arg2 = *argp2;
79391   {
79392     try {
79393       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
79394     } catch (std::out_of_range& e) {
79395       {
79396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79397       };
79398     } catch (std::exception& e) {
79399       {
79400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79401       };
79402     } catch (...) {
79403       {
79404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79405       };
79406     }
79407   }
79408   jresult = result;
79409   return jresult;
79410 }
79411
79412
79413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
79414   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79415   bool arg2 ;
79416
79417   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79418   arg2 = jarg2 ? true : false;
79419   {
79420     try {
79421       (arg1)->SetGroupMode(arg2);
79422     } catch (std::out_of_range& e) {
79423       {
79424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79425       };
79426     } catch (std::exception& e) {
79427       {
79428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79429       };
79430     } catch (...) {
79431       {
79432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79433       };
79434     }
79435   }
79436 }
79437
79438
79439 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
79440   unsigned int jresult ;
79441   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79442   bool result;
79443
79444   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79445   {
79446     try {
79447       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
79448     } catch (std::out_of_range& e) {
79449       {
79450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79451       };
79452     } catch (std::exception& e) {
79453       {
79454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79455       };
79456     } catch (...) {
79457       {
79458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79459       };
79460     }
79461   }
79462   jresult = result;
79463   return jresult;
79464 }
79465
79466
79467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
79468   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79469   bool arg2 ;
79470
79471   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79472   arg2 = jarg2 ? true : false;
79473   {
79474     try {
79475       (arg1)->SetWrapMode(arg2);
79476     } catch (std::out_of_range& e) {
79477       {
79478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79479       };
79480     } catch (std::exception& e) {
79481       {
79482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79483       };
79484     } catch (...) {
79485       {
79486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79487       };
79488     }
79489   }
79490 }
79491
79492
79493 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
79494   unsigned int jresult ;
79495   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79496   bool result;
79497
79498   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79499   {
79500     try {
79501       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
79502     } catch (std::out_of_range& e) {
79503       {
79504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79505       };
79506     } catch (std::exception& e) {
79507       {
79508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79509       };
79510     } catch (...) {
79511       {
79512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79513       };
79514     }
79515   }
79516   jresult = result;
79517   return jresult;
79518 }
79519
79520
79521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
79522   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79523   Dali::Actor arg2 ;
79524   Dali::Actor *argp2 ;
79525
79526   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79527   argp2 = (Dali::Actor *)jarg2;
79528   if (!argp2) {
79529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79530     return ;
79531   }
79532   arg2 = *argp2;
79533   {
79534     try {
79535       (arg1)->SetFocusIndicatorActor(arg2);
79536     } catch (std::out_of_range& e) {
79537       {
79538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79539       };
79540     } catch (std::exception& e) {
79541       {
79542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79543       };
79544     } catch (...) {
79545       {
79546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79547       };
79548     }
79549   }
79550 }
79551
79552
79553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
79554   void * jresult ;
79555   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79556   Dali::Actor result;
79557
79558   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79559   {
79560     try {
79561       result = (arg1)->GetFocusIndicatorActor();
79562     } catch (std::out_of_range& e) {
79563       {
79564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79565       };
79566     } catch (std::exception& e) {
79567       {
79568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79569       };
79570     } catch (...) {
79571       {
79572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79573       };
79574     }
79575   }
79576   jresult = new Dali::Actor((const Dali::Actor &)result);
79577   return jresult;
79578 }
79579
79580
79581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
79582   void * jresult ;
79583   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79584   Dali::Actor arg2 ;
79585   Dali::Actor *argp2 ;
79586   Dali::Actor result;
79587
79588   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79589   argp2 = (Dali::Actor *)jarg2;
79590   if (!argp2) {
79591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79592     return 0;
79593   }
79594   arg2 = *argp2;
79595   {
79596     try {
79597       result = (arg1)->GetFocusGroup(arg2);
79598     } catch (std::out_of_range& e) {
79599       {
79600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79601       };
79602     } catch (std::exception& e) {
79603       {
79604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79605       };
79606     } catch (...) {
79607       {
79608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79609       };
79610     }
79611   }
79612   jresult = new Dali::Actor((const Dali::Actor &)result);
79613   return jresult;
79614 }
79615
79616
79617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
79618   void * jresult ;
79619   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79620   Dali::Vector2 result;
79621
79622   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79623   {
79624     try {
79625       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
79626     } catch (std::out_of_range& e) {
79627       {
79628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79629       };
79630     } catch (std::exception& e) {
79631       {
79632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79633       };
79634     } catch (...) {
79635       {
79636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79637       };
79638     }
79639   }
79640   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
79641   return jresult;
79642 }
79643
79644
79645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
79646   void * jresult ;
79647   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79648   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
79649
79650   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79651   {
79652     try {
79653       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
79654     } catch (std::out_of_range& e) {
79655       {
79656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79657       };
79658     } catch (std::exception& e) {
79659       {
79660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79661       };
79662     } catch (...) {
79663       {
79664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79665       };
79666     }
79667   }
79668   jresult = (void *)result;
79669   return jresult;
79670 }
79671
79672
79673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
79674   void * jresult ;
79675   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79676   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
79677
79678   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79679   {
79680     try {
79681       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
79682     } catch (std::out_of_range& e) {
79683       {
79684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79685       };
79686     } catch (std::exception& e) {
79687       {
79688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79689       };
79690     } catch (...) {
79691       {
79692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79693       };
79694     }
79695   }
79696   jresult = (void *)result;
79697   return jresult;
79698 }
79699
79700
79701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
79702   void * jresult ;
79703   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79704   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
79705
79706   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79707   {
79708     try {
79709       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
79710     } catch (std::out_of_range& e) {
79711       {
79712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79713       };
79714     } catch (std::exception& e) {
79715       {
79716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79717       };
79718     } catch (...) {
79719       {
79720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79721       };
79722     }
79723   }
79724   jresult = (void *)result;
79725   return jresult;
79726 }
79727
79728
79729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
79730   void * jresult ;
79731   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79732   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79733
79734   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79735   {
79736     try {
79737       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
79738     } catch (std::out_of_range& e) {
79739       {
79740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79741       };
79742     } catch (std::exception& e) {
79743       {
79744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79745       };
79746     } catch (...) {
79747       {
79748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79749       };
79750     }
79751   }
79752   jresult = (void *)result;
79753   return jresult;
79754 }
79755
79756
79757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
79758   void * jresult ;
79759   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79760   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79761
79762   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79763   {
79764     try {
79765       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
79766     } catch (std::out_of_range& e) {
79767       {
79768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79769       };
79770     } catch (std::exception& e) {
79771       {
79772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79773       };
79774     } catch (...) {
79775       {
79776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79777       };
79778     }
79779   }
79780   jresult = (void *)result;
79781   return jresult;
79782 }
79783
79784
79785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
79786   void * jresult ;
79787   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79788   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79789
79790   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79791   {
79792     try {
79793       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
79794     } catch (std::out_of_range& e) {
79795       {
79796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79797       };
79798     } catch (std::exception& e) {
79799       {
79800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79801       };
79802     } catch (...) {
79803       {
79804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79805       };
79806     }
79807   }
79808   jresult = (void *)result;
79809   return jresult;
79810 }
79811
79812
79813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
79814   void * jresult ;
79815   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79816   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79817
79818   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79819   {
79820     try {
79821       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
79822     } catch (std::out_of_range& e) {
79823       {
79824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79825       };
79826     } catch (std::exception& e) {
79827       {
79828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79829       };
79830     } catch (...) {
79831       {
79832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79833       };
79834     }
79835   }
79836   jresult = (void *)result;
79837   return jresult;
79838 }
79839
79840
79841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
79842   void * jresult ;
79843   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79844   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79845
79846   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79847   {
79848     try {
79849       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
79850     } catch (std::out_of_range& e) {
79851       {
79852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79853       };
79854     } catch (std::exception& e) {
79855       {
79856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79857       };
79858     } catch (...) {
79859       {
79860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79861       };
79862     }
79863   }
79864   jresult = (void *)result;
79865   return jresult;
79866 }
79867
79868
79869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
79870   void * jresult ;
79871   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79872   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79873
79874   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79875   {
79876     try {
79877       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
79878     } catch (std::out_of_range& e) {
79879       {
79880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79881       };
79882     } catch (std::exception& e) {
79883       {
79884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79885       };
79886     } catch (...) {
79887       {
79888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79889       };
79890     }
79891   }
79892   jresult = (void *)result;
79893   return jresult;
79894 }
79895
79896
79897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
79898   void * jresult ;
79899   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79900   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79901
79902   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79903   {
79904     try {
79905       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
79906     } catch (std::out_of_range& e) {
79907       {
79908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79909       };
79910     } catch (std::exception& e) {
79911       {
79912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79913       };
79914     } catch (...) {
79915       {
79916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79917       };
79918     }
79919   }
79920   jresult = (void *)result;
79921   return jresult;
79922 }
79923
79924
79925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
79926   void * jresult ;
79927   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79928   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79929
79930   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79931   {
79932     try {
79933       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
79934     } catch (std::out_of_range& e) {
79935       {
79936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79937       };
79938     } catch (std::exception& e) {
79939       {
79940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79941       };
79942     } catch (...) {
79943       {
79944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79945       };
79946     }
79947   }
79948   jresult = (void *)result;
79949   return jresult;
79950 }
79951
79952
79953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
79954   void * jresult ;
79955   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79956   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79957
79958   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79959   {
79960     try {
79961       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
79962     } catch (std::out_of_range& e) {
79963       {
79964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79965       };
79966     } catch (std::exception& e) {
79967       {
79968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79969       };
79970     } catch (...) {
79971       {
79972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79973       };
79974     }
79975   }
79976   jresult = (void *)result;
79977   return jresult;
79978 }
79979
79980
79981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
79982   void * jresult ;
79983   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79984   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79985
79986   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79987   {
79988     try {
79989       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
79990     } catch (std::out_of_range& e) {
79991       {
79992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79993       };
79994     } catch (std::exception& e) {
79995       {
79996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79997       };
79998     } catch (...) {
79999       {
80000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80001       };
80002     }
80003   }
80004   jresult = (void *)result;
80005   return jresult;
80006 }
80007
80008
80009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
80010   void * jresult ;
80011   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80012   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80013
80014   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80015   {
80016     try {
80017       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
80018     } catch (std::out_of_range& e) {
80019       {
80020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80021       };
80022     } catch (std::exception& e) {
80023       {
80024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80025       };
80026     } catch (...) {
80027       {
80028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80029       };
80030     }
80031   }
80032   jresult = (void *)result;
80033   return jresult;
80034 }
80035
80036
80037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
80038   void * jresult ;
80039   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80040   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80041
80042   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80043   {
80044     try {
80045       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
80046     } catch (std::out_of_range& e) {
80047       {
80048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80049       };
80050     } catch (std::exception& e) {
80051       {
80052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80053       };
80054     } catch (...) {
80055       {
80056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80057       };
80058     }
80059   }
80060   jresult = (void *)result;
80061   return jresult;
80062 }
80063
80064
80065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
80066   void * jresult ;
80067   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80068   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80069
80070   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80071   {
80072     try {
80073       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
80074     } catch (std::out_of_range& e) {
80075       {
80076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80077       };
80078     } catch (std::exception& e) {
80079       {
80080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80081       };
80082     } catch (...) {
80083       {
80084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80085       };
80086     }
80087   }
80088   jresult = (void *)result;
80089   return jresult;
80090 }
80091
80092
80093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
80094   void * jresult ;
80095   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80096   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80097
80098   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80099   {
80100     try {
80101       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
80102     } catch (std::out_of_range& e) {
80103       {
80104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80105       };
80106     } catch (std::exception& e) {
80107       {
80108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80109       };
80110     } catch (...) {
80111       {
80112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80113       };
80114     }
80115   }
80116   jresult = (void *)result;
80117   return jresult;
80118 }
80119
80120
80121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
80122   void * jresult ;
80123   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80124   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80125
80126   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80127   {
80128     try {
80129       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
80130     } catch (std::out_of_range& e) {
80131       {
80132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80133       };
80134     } catch (std::exception& e) {
80135       {
80136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80137       };
80138     } catch (...) {
80139       {
80140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80141       };
80142     }
80143   }
80144   jresult = (void *)result;
80145   return jresult;
80146 }
80147
80148
80149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
80150   void * jresult ;
80151   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80152   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80153
80154   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80155   {
80156     try {
80157       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
80158     } catch (std::out_of_range& e) {
80159       {
80160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80161       };
80162     } catch (std::exception& e) {
80163       {
80164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80165       };
80166     } catch (...) {
80167       {
80168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80169       };
80170     }
80171   }
80172   jresult = (void *)result;
80173   return jresult;
80174 }
80175
80176
80177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
80178   void * jresult ;
80179   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80180   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80181
80182   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80183   {
80184     try {
80185       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
80186     } catch (std::out_of_range& e) {
80187       {
80188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80189       };
80190     } catch (std::exception& e) {
80191       {
80192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80193       };
80194     } catch (...) {
80195       {
80196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80197       };
80198     }
80199   }
80200   jresult = (void *)result;
80201   return jresult;
80202 }
80203
80204
80205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
80206   void * jresult ;
80207   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80208   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80209
80210   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80211   {
80212     try {
80213       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
80214     } catch (std::out_of_range& e) {
80215       {
80216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80217       };
80218     } catch (std::exception& e) {
80219       {
80220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80221       };
80222     } catch (...) {
80223       {
80224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80225       };
80226     }
80227   }
80228   jresult = (void *)result;
80229   return jresult;
80230 }
80231
80232
80233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
80234   void * jresult ;
80235   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80236   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80237
80238   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80239   {
80240     try {
80241       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
80242     } catch (std::out_of_range& e) {
80243       {
80244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80245       };
80246     } catch (std::exception& e) {
80247       {
80248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80249       };
80250     } catch (...) {
80251       {
80252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80253       };
80254     }
80255   }
80256   jresult = (void *)result;
80257   return jresult;
80258 }
80259
80260
80261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
80262   void * jresult ;
80263   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80264   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80265
80266   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80267   {
80268     try {
80269       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
80270     } catch (std::out_of_range& e) {
80271       {
80272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80273       };
80274     } catch (std::exception& e) {
80275       {
80276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80277       };
80278     } catch (...) {
80279       {
80280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80281       };
80282     }
80283   }
80284   jresult = (void *)result;
80285   return jresult;
80286 }
80287
80288
80289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
80290   void * jresult ;
80291   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80292   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80293
80294   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80295   {
80296     try {
80297       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
80298     } catch (std::out_of_range& e) {
80299       {
80300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80301       };
80302     } catch (std::exception& e) {
80303       {
80304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80305       };
80306     } catch (...) {
80307       {
80308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80309       };
80310     }
80311   }
80312   jresult = (void *)result;
80313   return jresult;
80314 }
80315
80316
80317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
80318   void * jresult ;
80319   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80320   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80321
80322   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80323   {
80324     try {
80325       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
80326     } catch (std::out_of_range& e) {
80327       {
80328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80329       };
80330     } catch (std::exception& e) {
80331       {
80332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80333       };
80334     } catch (...) {
80335       {
80336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80337       };
80338     }
80339   }
80340   jresult = (void *)result;
80341   return jresult;
80342 }
80343
80344
80345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
80346   void * jresult ;
80347   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80348   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80349
80350   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80351   {
80352     try {
80353       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
80354     } catch (std::out_of_range& e) {
80355       {
80356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80357       };
80358     } catch (std::exception& e) {
80359       {
80360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80361       };
80362     } catch (...) {
80363       {
80364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80365       };
80366     }
80367   }
80368   jresult = (void *)result;
80369   return jresult;
80370 }
80371
80372
80373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
80374   void * jresult ;
80375   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80376   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80377
80378   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80379   {
80380     try {
80381       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
80382     } catch (std::out_of_range& e) {
80383       {
80384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80385       };
80386     } catch (std::exception& e) {
80387       {
80388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80389       };
80390     } catch (...) {
80391       {
80392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80393       };
80394     }
80395   }
80396   jresult = (void *)result;
80397   return jresult;
80398 }
80399
80400
80401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
80402   void * jresult ;
80403   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80404   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80405
80406   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80407   {
80408     try {
80409       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
80410     } catch (std::out_of_range& e) {
80411       {
80412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80413       };
80414     } catch (std::exception& e) {
80415       {
80416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80417       };
80418     } catch (...) {
80419       {
80420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80421       };
80422     }
80423   }
80424   jresult = (void *)result;
80425   return jresult;
80426 }
80427
80428
80429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
80430   void * jresult ;
80431   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80432   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80433
80434   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80435   {
80436     try {
80437       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
80438     } catch (std::out_of_range& e) {
80439       {
80440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80441       };
80442     } catch (std::exception& e) {
80443       {
80444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80445       };
80446     } catch (...) {
80447       {
80448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80449       };
80450     }
80451   }
80452   jresult = (void *)result;
80453   return jresult;
80454 }
80455
80456
80457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
80458   void * jresult ;
80459   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80460   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
80461
80462   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80463   {
80464     try {
80465       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
80466     } catch (std::out_of_range& e) {
80467       {
80468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80469       };
80470     } catch (std::exception& e) {
80471       {
80472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80473       };
80474     } catch (...) {
80475       {
80476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80477       };
80478     }
80479   }
80480   jresult = (void *)result;
80481   return jresult;
80482 }
80483
80484
80485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
80486   void * jresult ;
80487   Dali::Toolkit::StyleManager *result = 0 ;
80488
80489   {
80490     try {
80491       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
80492     } catch (std::out_of_range& e) {
80493       {
80494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80495       };
80496     } catch (std::exception& e) {
80497       {
80498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80499       };
80500     } catch (...) {
80501       {
80502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80503       };
80504     }
80505   }
80506   jresult = (void *)result;
80507   return jresult;
80508 }
80509
80510
80511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
80512   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80513
80514   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80515   {
80516     try {
80517       delete arg1;
80518     } catch (std::out_of_range& e) {
80519       {
80520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80521       };
80522     } catch (std::exception& e) {
80523       {
80524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80525       };
80526     } catch (...) {
80527       {
80528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80529       };
80530     }
80531   }
80532 }
80533
80534
80535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
80536   void * jresult ;
80537   Dali::Toolkit::StyleManager result;
80538
80539   {
80540     try {
80541       result = Dali::Toolkit::StyleManager::Get();
80542     } catch (std::out_of_range& e) {
80543       {
80544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80545       };
80546     } catch (std::exception& e) {
80547       {
80548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80549       };
80550     } catch (...) {
80551       {
80552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80553       };
80554     }
80555   }
80556   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
80557   return jresult;
80558 }
80559
80560
80561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
80562   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80563   std::string *arg2 = 0 ;
80564
80565   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80566   if (!jarg2) {
80567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80568     return ;
80569   }
80570   std::string arg2_str(jarg2);
80571   arg2 = &arg2_str;
80572   {
80573     try {
80574       (arg1)->ApplyTheme((std::string const &)*arg2);
80575     } catch (std::out_of_range& e) {
80576       {
80577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80578       };
80579     } catch (std::exception& e) {
80580       {
80581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80582       };
80583     } catch (...) {
80584       {
80585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80586       };
80587     }
80588   }
80589
80590   //argout typemap for const std::string&
80591
80592 }
80593
80594
80595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
80596   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80597
80598   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80599   {
80600     try {
80601       (arg1)->ApplyDefaultTheme();
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_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
80620   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80621   std::string *arg2 = 0 ;
80622   Dali::Property::Value *arg3 = 0 ;
80623
80624   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80625   if (!jarg2) {
80626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80627     return ;
80628   }
80629   std::string arg2_str(jarg2);
80630   arg2 = &arg2_str;
80631   arg3 = (Dali::Property::Value *)jarg3;
80632   if (!arg3) {
80633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
80634     return ;
80635   }
80636   {
80637     try {
80638       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
80639     } catch (std::out_of_range& e) {
80640       {
80641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80642       };
80643     } catch (std::exception& e) {
80644       {
80645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80646       };
80647     } catch (...) {
80648       {
80649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80650       };
80651     }
80652   }
80653
80654   //argout typemap for const std::string&
80655
80656 }
80657
80658
80659 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
80660   unsigned int jresult ;
80661   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80662   std::string *arg2 = 0 ;
80663   Dali::Property::Value *arg3 = 0 ;
80664   bool result;
80665
80666   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80667   if (!jarg2) {
80668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80669     return 0;
80670   }
80671   std::string arg2_str(jarg2);
80672   arg2 = &arg2_str;
80673   arg3 = (Dali::Property::Value *)jarg3;
80674   if (!arg3) {
80675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
80676     return 0;
80677   }
80678   {
80679     try {
80680       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
80681     } catch (std::out_of_range& e) {
80682       {
80683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80684       };
80685     } catch (std::exception& e) {
80686       {
80687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80688       };
80689     } catch (...) {
80690       {
80691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80692       };
80693     }
80694   }
80695   jresult = result;
80696
80697   //argout typemap for const std::string&
80698
80699   return jresult;
80700 }
80701
80702
80703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
80704   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80705   Dali::Toolkit::Control arg2 ;
80706   std::string *arg3 = 0 ;
80707   std::string *arg4 = 0 ;
80708   Dali::Toolkit::Control *argp2 ;
80709
80710   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80711   argp2 = (Dali::Toolkit::Control *)jarg2;
80712   if (!argp2) {
80713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
80714     return ;
80715   }
80716   arg2 = *argp2;
80717   if (!jarg3) {
80718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80719     return ;
80720   }
80721   std::string arg3_str(jarg3);
80722   arg3 = &arg3_str;
80723   if (!jarg4) {
80724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80725     return ;
80726   }
80727   std::string arg4_str(jarg4);
80728   arg4 = &arg4_str;
80729   {
80730     try {
80731       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
80732     } catch (std::out_of_range& e) {
80733       {
80734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80735       };
80736     } catch (std::exception& e) {
80737       {
80738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80739       };
80740     } catch (...) {
80741       {
80742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80743       };
80744     }
80745   }
80746
80747   //argout typemap for const std::string&
80748
80749
80750   //argout typemap for const std::string&
80751
80752 }
80753
80754
80755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
80756   void * jresult ;
80757   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80758   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
80759
80760   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80761   {
80762     try {
80763       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
80764     } catch (std::out_of_range& e) {
80765       {
80766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80767       };
80768     } catch (std::exception& e) {
80769       {
80770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80771       };
80772     } catch (...) {
80773       {
80774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80775       };
80776     }
80777   }
80778   jresult = (void *)result;
80779   return jresult;
80780 }
80781
80782
80783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
80784   int jresult ;
80785   int result;
80786
80787   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
80788   jresult = (int)result;
80789   return jresult;
80790 }
80791
80792
80793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
80794   int jresult ;
80795   int result;
80796
80797   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
80798   jresult = (int)result;
80799   return jresult;
80800 }
80801
80802
80803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
80804   int jresult ;
80805   int result;
80806
80807   result = (int)Dali::Toolkit::Slider::Property::VALUE;
80808   jresult = (int)result;
80809   return jresult;
80810 }
80811
80812
80813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
80814   int jresult ;
80815   int result;
80816
80817   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
80818   jresult = (int)result;
80819   return jresult;
80820 }
80821
80822
80823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
80824   int jresult ;
80825   int result;
80826
80827   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
80828   jresult = (int)result;
80829   return jresult;
80830 }
80831
80832
80833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
80834   int jresult ;
80835   int result;
80836
80837   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
80838   jresult = (int)result;
80839   return jresult;
80840 }
80841
80842
80843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
80844   int jresult ;
80845   int result;
80846
80847   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
80848   jresult = (int)result;
80849   return jresult;
80850 }
80851
80852
80853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
80854   int jresult ;
80855   int result;
80856
80857   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
80858   jresult = (int)result;
80859   return jresult;
80860 }
80861
80862
80863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
80864   int jresult ;
80865   int result;
80866
80867   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
80868   jresult = (int)result;
80869   return jresult;
80870 }
80871
80872
80873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
80874   int jresult ;
80875   int result;
80876
80877   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
80878   jresult = (int)result;
80879   return jresult;
80880 }
80881
80882
80883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
80884   int jresult ;
80885   int result;
80886
80887   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
80888   jresult = (int)result;
80889   return jresult;
80890 }
80891
80892
80893 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
80894   int jresult ;
80895   int result;
80896
80897   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
80898   jresult = (int)result;
80899   return jresult;
80900 }
80901
80902
80903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
80904   int jresult ;
80905   int result;
80906
80907   result = (int)Dali::Toolkit::Slider::Property::MARKS;
80908   jresult = (int)result;
80909   return jresult;
80910 }
80911
80912
80913 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
80914   int jresult ;
80915   int result;
80916
80917   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
80918   jresult = (int)result;
80919   return jresult;
80920 }
80921
80922
80923 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
80924   int jresult ;
80925   int result;
80926
80927   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
80928   jresult = (int)result;
80929   return jresult;
80930 }
80931
80932
80933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
80934   void * jresult ;
80935   Dali::Toolkit::Slider::Property *result = 0 ;
80936
80937   {
80938     try {
80939       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
80940     } catch (std::out_of_range& e) {
80941       {
80942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80943       };
80944     } catch (std::exception& e) {
80945       {
80946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80947       };
80948     } catch (...) {
80949       {
80950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80951       };
80952     }
80953   }
80954   jresult = (void *)result;
80955   return jresult;
80956 }
80957
80958
80959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
80960   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
80961
80962   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
80963   {
80964     try {
80965       delete arg1;
80966     } catch (std::out_of_range& e) {
80967       {
80968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80969       };
80970     } catch (std::exception& e) {
80971       {
80972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80973       };
80974     } catch (...) {
80975       {
80976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80977       };
80978     }
80979   }
80980 }
80981
80982
80983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
80984   void * jresult ;
80985   Dali::Toolkit::Slider result;
80986
80987   {
80988     try {
80989       result = Dali::Toolkit::Slider::New();
80990     } catch (std::out_of_range& e) {
80991       {
80992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80993       };
80994     } catch (std::exception& e) {
80995       {
80996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80997       };
80998     } catch (...) {
80999       {
81000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81001       };
81002     }
81003   }
81004   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81005   return jresult;
81006 }
81007
81008
81009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
81010   void * jresult ;
81011   Dali::Toolkit::Slider *result = 0 ;
81012
81013   {
81014     try {
81015       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
81016     } catch (std::out_of_range& e) {
81017       {
81018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81019       };
81020     } catch (std::exception& e) {
81021       {
81022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81023       };
81024     } catch (...) {
81025       {
81026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81027       };
81028     }
81029   }
81030   jresult = (void *)result;
81031   return jresult;
81032 }
81033
81034
81035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
81036   void * jresult ;
81037   Dali::Toolkit::Slider *arg1 = 0 ;
81038   Dali::Toolkit::Slider *result = 0 ;
81039
81040   arg1 = (Dali::Toolkit::Slider *)jarg1;
81041   if (!arg1) {
81042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81043     return 0;
81044   }
81045   {
81046     try {
81047       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
81048     } catch (std::out_of_range& e) {
81049       {
81050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81051       };
81052     } catch (std::exception& e) {
81053       {
81054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81055       };
81056     } catch (...) {
81057       {
81058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81059       };
81060     }
81061   }
81062   jresult = (void *)result;
81063   return jresult;
81064 }
81065
81066
81067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
81068   void * jresult ;
81069   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81070   Dali::Toolkit::Slider *arg2 = 0 ;
81071   Dali::Toolkit::Slider *result = 0 ;
81072
81073   arg1 = (Dali::Toolkit::Slider *)jarg1;
81074   arg2 = (Dali::Toolkit::Slider *)jarg2;
81075   if (!arg2) {
81076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81077     return 0;
81078   }
81079   {
81080     try {
81081       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
81082     } catch (std::out_of_range& e) {
81083       {
81084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81085       };
81086     } catch (std::exception& e) {
81087       {
81088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81089       };
81090     } catch (...) {
81091       {
81092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81093       };
81094     }
81095   }
81096   jresult = (void *)result;
81097   return jresult;
81098 }
81099
81100
81101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
81102   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81103
81104   arg1 = (Dali::Toolkit::Slider *)jarg1;
81105   {
81106     try {
81107       delete arg1;
81108     } catch (std::out_of_range& e) {
81109       {
81110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81111       };
81112     } catch (std::exception& e) {
81113       {
81114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81115       };
81116     } catch (...) {
81117       {
81118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81119       };
81120     }
81121   }
81122 }
81123
81124
81125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
81126   void * jresult ;
81127   Dali::BaseHandle arg1 ;
81128   Dali::BaseHandle *argp1 ;
81129   Dali::Toolkit::Slider result;
81130
81131   argp1 = (Dali::BaseHandle *)jarg1;
81132   if (!argp1) {
81133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81134     return 0;
81135   }
81136   arg1 = *argp1;
81137   {
81138     try {
81139       result = Dali::Toolkit::Slider::DownCast(arg1);
81140     } catch (std::out_of_range& e) {
81141       {
81142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81143       };
81144     } catch (std::exception& e) {
81145       {
81146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81147       };
81148     } catch (...) {
81149       {
81150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81151       };
81152     }
81153   }
81154   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81155   return jresult;
81156 }
81157
81158
81159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
81160   void * jresult ;
81161   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81162   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81163
81164   arg1 = (Dali::Toolkit::Slider *)jarg1;
81165   {
81166     try {
81167       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
81168     } catch (std::out_of_range& e) {
81169       {
81170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81171       };
81172     } catch (std::exception& e) {
81173       {
81174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81175       };
81176     } catch (...) {
81177       {
81178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81179       };
81180     }
81181   }
81182   jresult = (void *)result;
81183   return jresult;
81184 }
81185
81186
81187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
81188   void * jresult ;
81189   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81190   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81191
81192   arg1 = (Dali::Toolkit::Slider *)jarg1;
81193   {
81194     try {
81195       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
81196     } catch (std::out_of_range& e) {
81197       {
81198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81199       };
81200     } catch (std::exception& e) {
81201       {
81202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81203       };
81204     } catch (...) {
81205       {
81206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81207       };
81208     }
81209   }
81210   jresult = (void *)result;
81211   return jresult;
81212 }
81213
81214
81215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
81216   void * jresult ;
81217   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81218   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
81219
81220   arg1 = (Dali::Toolkit::Slider *)jarg1;
81221   {
81222     try {
81223       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
81224     } catch (std::out_of_range& e) {
81225       {
81226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81227       };
81228     } catch (std::exception& e) {
81229       {
81230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81231       };
81232     } catch (...) {
81233       {
81234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81235       };
81236     }
81237   }
81238   jresult = (void *)result;
81239   return jresult;
81240 }
81241
81242
81243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
81244   int jresult ;
81245   int result;
81246
81247   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
81248   jresult = (int)result;
81249   return jresult;
81250 }
81251
81252
81253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
81254   int jresult ;
81255   int result;
81256
81257   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
81258   jresult = (int)result;
81259   return jresult;
81260 }
81261
81262
81263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
81264   int jresult ;
81265   int result;
81266
81267   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
81268   jresult = (int)result;
81269   return jresult;
81270 }
81271
81272
81273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
81274   int jresult ;
81275   int result;
81276
81277   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
81278   jresult = (int)result;
81279   return jresult;
81280 }
81281
81282
81283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
81284   void * jresult ;
81285   Dali::Toolkit::VideoView::Property *result = 0 ;
81286
81287   {
81288     try {
81289       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
81290     } catch (std::out_of_range& e) {
81291       {
81292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81293       };
81294     } catch (std::exception& e) {
81295       {
81296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81297       };
81298     } catch (...) {
81299       {
81300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81301       };
81302     }
81303   }
81304   jresult = (void *)result;
81305   return jresult;
81306 }
81307
81308
81309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
81310   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
81311
81312   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
81313   {
81314     try {
81315       delete arg1;
81316     } catch (std::out_of_range& e) {
81317       {
81318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81319       };
81320     } catch (std::exception& e) {
81321       {
81322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81323       };
81324     } catch (...) {
81325       {
81326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81327       };
81328     }
81329   }
81330 }
81331
81332
81333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
81334   void * jresult ;
81335   Dali::Toolkit::VideoView result;
81336
81337   {
81338     try {
81339       result = Dali::Toolkit::VideoView::New();
81340     } catch (std::out_of_range& e) {
81341       {
81342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81343       };
81344     } catch (std::exception& e) {
81345       {
81346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81347       };
81348     } catch (...) {
81349       {
81350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81351       };
81352     }
81353   }
81354   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81355   return jresult;
81356 }
81357
81358
81359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
81360   void * jresult ;
81361   std::string *arg1 = 0 ;
81362   Dali::Toolkit::VideoView result;
81363
81364   if (!jarg1) {
81365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81366     return 0;
81367   }
81368   std::string arg1_str(jarg1);
81369   arg1 = &arg1_str;
81370   {
81371     try {
81372       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
81373     } catch (std::out_of_range& e) {
81374       {
81375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81376       };
81377     } catch (std::exception& e) {
81378       {
81379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81380       };
81381     } catch (...) {
81382       {
81383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81384       };
81385     }
81386   }
81387   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81388
81389   //argout typemap for const std::string&
81390
81391   return jresult;
81392 }
81393
81394
81395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
81396   void * jresult ;
81397   Dali::Toolkit::VideoView *result = 0 ;
81398
81399   {
81400     try {
81401       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
81402     } catch (std::out_of_range& e) {
81403       {
81404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81405       };
81406     } catch (std::exception& e) {
81407       {
81408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81409       };
81410     } catch (...) {
81411       {
81412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81413       };
81414     }
81415   }
81416   jresult = (void *)result;
81417   return jresult;
81418 }
81419
81420
81421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
81422   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81423
81424   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81425   {
81426     try {
81427       delete arg1;
81428     } catch (std::out_of_range& e) {
81429       {
81430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81431       };
81432     } catch (std::exception& e) {
81433       {
81434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81435       };
81436     } catch (...) {
81437       {
81438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81439       };
81440     }
81441   }
81442 }
81443
81444
81445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
81446   void * jresult ;
81447   Dali::Toolkit::VideoView *arg1 = 0 ;
81448   Dali::Toolkit::VideoView *result = 0 ;
81449
81450   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81451   if (!arg1) {
81452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
81453     return 0;
81454   }
81455   {
81456     try {
81457       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
81458     } catch (std::out_of_range& e) {
81459       {
81460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81461       };
81462     } catch (std::exception& e) {
81463       {
81464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81465       };
81466     } catch (...) {
81467       {
81468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81469       };
81470     }
81471   }
81472   jresult = (void *)result;
81473   return jresult;
81474 }
81475
81476
81477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
81478   void * jresult ;
81479   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81480   Dali::Toolkit::VideoView *arg2 = 0 ;
81481   Dali::Toolkit::VideoView *result = 0 ;
81482
81483   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81484   arg2 = (Dali::Toolkit::VideoView *)jarg2;
81485   if (!arg2) {
81486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
81487     return 0;
81488   }
81489   {
81490     try {
81491       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
81492     } catch (std::out_of_range& e) {
81493       {
81494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81495       };
81496     } catch (std::exception& e) {
81497       {
81498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81499       };
81500     } catch (...) {
81501       {
81502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81503       };
81504     }
81505   }
81506   jresult = (void *)result;
81507   return jresult;
81508 }
81509
81510
81511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
81512   void * jresult ;
81513   Dali::BaseHandle arg1 ;
81514   Dali::BaseHandle *argp1 ;
81515   Dali::Toolkit::VideoView result;
81516
81517   argp1 = (Dali::BaseHandle *)jarg1;
81518   if (!argp1) {
81519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81520     return 0;
81521   }
81522   arg1 = *argp1;
81523   {
81524     try {
81525       result = Dali::Toolkit::VideoView::DownCast(arg1);
81526     } catch (std::out_of_range& e) {
81527       {
81528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81529       };
81530     } catch (std::exception& e) {
81531       {
81532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81533       };
81534     } catch (...) {
81535       {
81536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81537       };
81538     }
81539   }
81540   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81541   return jresult;
81542 }
81543
81544
81545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
81546   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81547
81548   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81549   {
81550     try {
81551       (arg1)->Play();
81552     } catch (std::out_of_range& e) {
81553       {
81554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81555       };
81556     } catch (std::exception& e) {
81557       {
81558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81559       };
81560     } catch (...) {
81561       {
81562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81563       };
81564     }
81565   }
81566 }
81567
81568
81569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
81570   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81571
81572   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81573   {
81574     try {
81575       (arg1)->Pause();
81576     } catch (std::out_of_range& e) {
81577       {
81578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81579       };
81580     } catch (std::exception& e) {
81581       {
81582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81583       };
81584     } catch (...) {
81585       {
81586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81587       };
81588     }
81589   }
81590 }
81591
81592
81593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
81594   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81595
81596   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81597   {
81598     try {
81599       (arg1)->Stop();
81600     } catch (std::out_of_range& e) {
81601       {
81602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81603       };
81604     } catch (std::exception& e) {
81605       {
81606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81607       };
81608     } catch (...) {
81609       {
81610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81611       };
81612     }
81613   }
81614 }
81615
81616
81617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
81618   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81619   int arg2 ;
81620
81621   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81622   arg2 = (int)jarg2;
81623   {
81624     try {
81625       (arg1)->Forward(arg2);
81626     } catch (std::out_of_range& e) {
81627       {
81628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81629       };
81630     } catch (std::exception& e) {
81631       {
81632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81633       };
81634     } catch (...) {
81635       {
81636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81637       };
81638     }
81639   }
81640 }
81641
81642
81643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
81644   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81645   int arg2 ;
81646
81647   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81648   arg2 = (int)jarg2;
81649   {
81650     try {
81651       (arg1)->Backward(arg2);
81652     } catch (std::out_of_range& e) {
81653       {
81654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81655       };
81656     } catch (std::exception& e) {
81657       {
81658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81659       };
81660     } catch (...) {
81661       {
81662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81663       };
81664     }
81665   }
81666 }
81667
81668
81669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
81670   void * jresult ;
81671   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81672   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
81673
81674   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81675   {
81676     try {
81677       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
81678     } catch (std::out_of_range& e) {
81679       {
81680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81681       };
81682     } catch (std::exception& e) {
81683       {
81684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81685       };
81686     } catch (...) {
81687       {
81688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81689       };
81690     }
81691   }
81692   jresult = (void *)result;
81693   return jresult;
81694 }
81695
81696
81697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
81698   int jresult ;
81699   int result;
81700
81701   result = (int)Dali::Toolkit::Popup::Property::TITLE;
81702   jresult = (int)result;
81703   return jresult;
81704 }
81705
81706
81707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
81708   int jresult ;
81709   int result;
81710
81711   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
81712   jresult = (int)result;
81713   return jresult;
81714 }
81715
81716
81717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
81718   int jresult ;
81719   int result;
81720
81721   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
81722   jresult = (int)result;
81723   return jresult;
81724 }
81725
81726
81727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
81728   int jresult ;
81729   int result;
81730
81731   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
81732   jresult = (int)result;
81733   return jresult;
81734 }
81735
81736
81737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
81738   int jresult ;
81739   int result;
81740
81741   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
81742   jresult = (int)result;
81743   return jresult;
81744 }
81745
81746
81747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
81748   int jresult ;
81749   int result;
81750
81751   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
81752   jresult = (int)result;
81753   return jresult;
81754 }
81755
81756
81757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
81758   int jresult ;
81759   int result;
81760
81761   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
81762   jresult = (int)result;
81763   return jresult;
81764 }
81765
81766
81767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
81768   int jresult ;
81769   int result;
81770
81771   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
81772   jresult = (int)result;
81773   return jresult;
81774 }
81775
81776
81777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
81778   int jresult ;
81779   int result;
81780
81781   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
81782   jresult = (int)result;
81783   return jresult;
81784 }
81785
81786
81787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
81788   int jresult ;
81789   int result;
81790
81791   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
81792   jresult = (int)result;
81793   return jresult;
81794 }
81795
81796
81797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
81798   int jresult ;
81799   int result;
81800
81801   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
81802   jresult = (int)result;
81803   return jresult;
81804 }
81805
81806
81807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
81808   int jresult ;
81809   int result;
81810
81811   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
81812   jresult = (int)result;
81813   return jresult;
81814 }
81815
81816
81817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
81818   int jresult ;
81819   int result;
81820
81821   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
81822   jresult = (int)result;
81823   return jresult;
81824 }
81825
81826
81827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
81828   int jresult ;
81829   int result;
81830
81831   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
81832   jresult = (int)result;
81833   return jresult;
81834 }
81835
81836
81837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
81838   int jresult ;
81839   int result;
81840
81841   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
81842   jresult = (int)result;
81843   return jresult;
81844 }
81845
81846
81847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
81848   int jresult ;
81849   int result;
81850
81851   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
81852   jresult = (int)result;
81853   return jresult;
81854 }
81855
81856
81857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
81858   int jresult ;
81859   int result;
81860
81861   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
81862   jresult = (int)result;
81863   return jresult;
81864 }
81865
81866
81867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
81868   int jresult ;
81869   int result;
81870
81871   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
81872   jresult = (int)result;
81873   return jresult;
81874 }
81875
81876
81877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
81878   int jresult ;
81879   int result;
81880
81881   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
81882   jresult = (int)result;
81883   return jresult;
81884 }
81885
81886
81887 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
81888   int jresult ;
81889   int result;
81890
81891   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
81892   jresult = (int)result;
81893   return jresult;
81894 }
81895
81896
81897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
81898   int jresult ;
81899   int result;
81900
81901   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
81902   jresult = (int)result;
81903   return jresult;
81904 }
81905
81906
81907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
81908   void * jresult ;
81909   Dali::Toolkit::Popup::Property *result = 0 ;
81910
81911   {
81912     try {
81913       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
81914     } catch (std::out_of_range& e) {
81915       {
81916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81917       };
81918     } catch (std::exception& e) {
81919       {
81920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81921       };
81922     } catch (...) {
81923       {
81924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81925       };
81926     }
81927   }
81928   jresult = (void *)result;
81929   return jresult;
81930 }
81931
81932
81933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
81934   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
81935
81936   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
81937   {
81938     try {
81939       delete arg1;
81940     } catch (std::out_of_range& e) {
81941       {
81942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81943       };
81944     } catch (std::exception& e) {
81945       {
81946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81947       };
81948     } catch (...) {
81949       {
81950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81951       };
81952     }
81953   }
81954 }
81955
81956
81957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
81958   void * jresult ;
81959   Dali::Toolkit::Popup *result = 0 ;
81960
81961   {
81962     try {
81963       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
81964     } catch (std::out_of_range& e) {
81965       {
81966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81967       };
81968     } catch (std::exception& e) {
81969       {
81970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81971       };
81972     } catch (...) {
81973       {
81974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81975       };
81976     }
81977   }
81978   jresult = (void *)result;
81979   return jresult;
81980 }
81981
81982
81983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
81984   void * jresult ;
81985   Dali::Toolkit::Popup result;
81986
81987   {
81988     try {
81989       result = Dali::Toolkit::Popup::New();
81990     } catch (std::out_of_range& e) {
81991       {
81992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81993       };
81994     } catch (std::exception& e) {
81995       {
81996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81997       };
81998     } catch (...) {
81999       {
82000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82001       };
82002     }
82003   }
82004   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82005   return jresult;
82006 }
82007
82008
82009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
82010   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82011
82012   arg1 = (Dali::Toolkit::Popup *)jarg1;
82013   {
82014     try {
82015       delete arg1;
82016     } catch (std::out_of_range& e) {
82017       {
82018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82019       };
82020     } catch (std::exception& e) {
82021       {
82022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82023       };
82024     } catch (...) {
82025       {
82026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82027       };
82028     }
82029   }
82030 }
82031
82032
82033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
82034   void * jresult ;
82035   Dali::Toolkit::Popup *arg1 = 0 ;
82036   Dali::Toolkit::Popup *result = 0 ;
82037
82038   arg1 = (Dali::Toolkit::Popup *)jarg1;
82039   if (!arg1) {
82040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
82041     return 0;
82042   }
82043   {
82044     try {
82045       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
82046     } catch (std::out_of_range& e) {
82047       {
82048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82049       };
82050     } catch (std::exception& e) {
82051       {
82052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82053       };
82054     } catch (...) {
82055       {
82056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82057       };
82058     }
82059   }
82060   jresult = (void *)result;
82061   return jresult;
82062 }
82063
82064
82065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
82066   void * jresult ;
82067   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82068   Dali::Toolkit::Popup *arg2 = 0 ;
82069   Dali::Toolkit::Popup *result = 0 ;
82070
82071   arg1 = (Dali::Toolkit::Popup *)jarg1;
82072   arg2 = (Dali::Toolkit::Popup *)jarg2;
82073   if (!arg2) {
82074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
82075     return 0;
82076   }
82077   {
82078     try {
82079       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
82080     } catch (std::out_of_range& e) {
82081       {
82082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82083       };
82084     } catch (std::exception& e) {
82085       {
82086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82087       };
82088     } catch (...) {
82089       {
82090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82091       };
82092     }
82093   }
82094   jresult = (void *)result;
82095   return jresult;
82096 }
82097
82098
82099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
82100   void * jresult ;
82101   Dali::BaseHandle arg1 ;
82102   Dali::BaseHandle *argp1 ;
82103   Dali::Toolkit::Popup result;
82104
82105   argp1 = (Dali::BaseHandle *)jarg1;
82106   if (!argp1) {
82107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82108     return 0;
82109   }
82110   arg1 = *argp1;
82111   {
82112     try {
82113       result = Dali::Toolkit::Popup::DownCast(arg1);
82114     } catch (std::out_of_range& e) {
82115       {
82116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82117       };
82118     } catch (std::exception& e) {
82119       {
82120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82121       };
82122     } catch (...) {
82123       {
82124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82125       };
82126     }
82127   }
82128   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82129   return jresult;
82130 }
82131
82132
82133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
82134   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82135   Dali::Actor arg2 ;
82136   Dali::Actor *argp2 ;
82137
82138   arg1 = (Dali::Toolkit::Popup *)jarg1;
82139   argp2 = (Dali::Actor *)jarg2;
82140   if (!argp2) {
82141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82142     return ;
82143   }
82144   arg2 = *argp2;
82145   {
82146     try {
82147       (arg1)->SetTitle(arg2);
82148     } catch (std::out_of_range& e) {
82149       {
82150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82151       };
82152     } catch (std::exception& e) {
82153       {
82154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82155       };
82156     } catch (...) {
82157       {
82158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82159       };
82160     }
82161   }
82162 }
82163
82164
82165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
82166   void * jresult ;
82167   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82168   Dali::Actor result;
82169
82170   arg1 = (Dali::Toolkit::Popup *)jarg1;
82171   {
82172     try {
82173       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
82174     } catch (std::out_of_range& e) {
82175       {
82176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82177       };
82178     } catch (std::exception& e) {
82179       {
82180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82181       };
82182     } catch (...) {
82183       {
82184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82185       };
82186     }
82187   }
82188   jresult = new Dali::Actor((const Dali::Actor &)result);
82189   return jresult;
82190 }
82191
82192
82193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
82194   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82195   Dali::Actor arg2 ;
82196   Dali::Actor *argp2 ;
82197
82198   arg1 = (Dali::Toolkit::Popup *)jarg1;
82199   argp2 = (Dali::Actor *)jarg2;
82200   if (!argp2) {
82201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82202     return ;
82203   }
82204   arg2 = *argp2;
82205   {
82206     try {
82207       (arg1)->SetContent(arg2);
82208     } catch (std::out_of_range& e) {
82209       {
82210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82211       };
82212     } catch (std::exception& e) {
82213       {
82214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82215       };
82216     } catch (...) {
82217       {
82218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82219       };
82220     }
82221   }
82222 }
82223
82224
82225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
82226   void * jresult ;
82227   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82228   Dali::Actor result;
82229
82230   arg1 = (Dali::Toolkit::Popup *)jarg1;
82231   {
82232     try {
82233       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
82234     } catch (std::out_of_range& e) {
82235       {
82236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82237       };
82238     } catch (std::exception& e) {
82239       {
82240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82241       };
82242     } catch (...) {
82243       {
82244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82245       };
82246     }
82247   }
82248   jresult = new Dali::Actor((const Dali::Actor &)result);
82249   return jresult;
82250 }
82251
82252
82253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
82254   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82255   Dali::Actor arg2 ;
82256   Dali::Actor *argp2 ;
82257
82258   arg1 = (Dali::Toolkit::Popup *)jarg1;
82259   argp2 = (Dali::Actor *)jarg2;
82260   if (!argp2) {
82261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82262     return ;
82263   }
82264   arg2 = *argp2;
82265   {
82266     try {
82267       (arg1)->SetFooter(arg2);
82268     } catch (std::out_of_range& e) {
82269       {
82270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82271       };
82272     } catch (std::exception& e) {
82273       {
82274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82275       };
82276     } catch (...) {
82277       {
82278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82279       };
82280     }
82281   }
82282 }
82283
82284
82285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
82286   void * jresult ;
82287   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82288   Dali::Actor result;
82289
82290   arg1 = (Dali::Toolkit::Popup *)jarg1;
82291   {
82292     try {
82293       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
82294     } catch (std::out_of_range& e) {
82295       {
82296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82297       };
82298     } catch (std::exception& e) {
82299       {
82300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82301       };
82302     } catch (...) {
82303       {
82304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82305       };
82306     }
82307   }
82308   jresult = new Dali::Actor((const Dali::Actor &)result);
82309   return jresult;
82310 }
82311
82312
82313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
82314   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82315   Dali::Toolkit::Popup::DisplayState arg2 ;
82316
82317   arg1 = (Dali::Toolkit::Popup *)jarg1;
82318   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
82319   {
82320     try {
82321       (arg1)->SetDisplayState(arg2);
82322     } catch (std::out_of_range& e) {
82323       {
82324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82325       };
82326     } catch (std::exception& e) {
82327       {
82328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82329       };
82330     } catch (...) {
82331       {
82332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82333       };
82334     }
82335   }
82336 }
82337
82338
82339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
82340   int jresult ;
82341   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82342   Dali::Toolkit::Popup::DisplayState result;
82343
82344   arg1 = (Dali::Toolkit::Popup *)jarg1;
82345   {
82346     try {
82347       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
82348     } catch (std::out_of_range& e) {
82349       {
82350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82351       };
82352     } catch (std::exception& e) {
82353       {
82354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82355       };
82356     } catch (...) {
82357       {
82358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82359       };
82360     }
82361   }
82362   jresult = (int)result;
82363   return jresult;
82364 }
82365
82366
82367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
82368   void * jresult ;
82369   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82370   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
82371
82372   arg1 = (Dali::Toolkit::Popup *)jarg1;
82373   {
82374     try {
82375       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
82376     } catch (std::out_of_range& e) {
82377       {
82378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82379       };
82380     } catch (std::exception& e) {
82381       {
82382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82383       };
82384     } catch (...) {
82385       {
82386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82387       };
82388     }
82389   }
82390   jresult = (void *)result;
82391   return jresult;
82392 }
82393
82394
82395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
82396   void * jresult ;
82397   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82398   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82399
82400   arg1 = (Dali::Toolkit::Popup *)jarg1;
82401   {
82402     try {
82403       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
82404     } catch (std::out_of_range& e) {
82405       {
82406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82407       };
82408     } catch (std::exception& e) {
82409       {
82410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82411       };
82412     } catch (...) {
82413       {
82414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82415       };
82416     }
82417   }
82418   jresult = (void *)result;
82419   return jresult;
82420 }
82421
82422
82423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
82424   void * jresult ;
82425   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82426   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82427
82428   arg1 = (Dali::Toolkit::Popup *)jarg1;
82429   {
82430     try {
82431       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
82432     } catch (std::out_of_range& e) {
82433       {
82434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82435       };
82436     } catch (std::exception& e) {
82437       {
82438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82439       };
82440     } catch (...) {
82441       {
82442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82443       };
82444     }
82445   }
82446   jresult = (void *)result;
82447   return jresult;
82448 }
82449
82450
82451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
82452   void * jresult ;
82453   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82454   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82455
82456   arg1 = (Dali::Toolkit::Popup *)jarg1;
82457   {
82458     try {
82459       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
82460     } catch (std::out_of_range& e) {
82461       {
82462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82463       };
82464     } catch (std::exception& e) {
82465       {
82466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82467       };
82468     } catch (...) {
82469       {
82470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82471       };
82472     }
82473   }
82474   jresult = (void *)result;
82475   return jresult;
82476 }
82477
82478
82479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
82480   void * jresult ;
82481   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82482   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82483
82484   arg1 = (Dali::Toolkit::Popup *)jarg1;
82485   {
82486     try {
82487       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
82488     } catch (std::out_of_range& e) {
82489       {
82490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82491       };
82492     } catch (std::exception& e) {
82493       {
82494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82495       };
82496     } catch (...) {
82497       {
82498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82499       };
82500     }
82501   }
82502   jresult = (void *)result;
82503   return jresult;
82504 }
82505
82506
82507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
82508   int jresult ;
82509   int result;
82510
82511   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
82512   jresult = (int)result;
82513   return jresult;
82514 }
82515
82516
82517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
82518   int jresult ;
82519   int result;
82520
82521   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
82522   jresult = (int)result;
82523   return jresult;
82524 }
82525
82526
82527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
82528   int jresult ;
82529   int result;
82530
82531   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
82532   jresult = (int)result;
82533   return jresult;
82534 }
82535
82536
82537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
82538   int jresult ;
82539   int result;
82540
82541   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
82542   jresult = (int)result;
82543   return jresult;
82544 }
82545
82546
82547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
82548   int jresult ;
82549   int result;
82550
82551   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
82552   jresult = (int)result;
82553   return jresult;
82554 }
82555
82556
82557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
82558   int jresult ;
82559   int result;
82560
82561   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
82562   jresult = (int)result;
82563   return jresult;
82564 }
82565
82566
82567 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
82568   int jresult ;
82569   int result;
82570
82571   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
82572   jresult = (int)result;
82573   return jresult;
82574 }
82575
82576
82577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
82578   int jresult ;
82579   int result;
82580
82581   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
82582   jresult = (int)result;
82583   return jresult;
82584 }
82585
82586
82587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
82588   int jresult ;
82589   int result;
82590
82591   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
82592   jresult = (int)result;
82593   return jresult;
82594 }
82595
82596
82597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
82598   void * jresult ;
82599   Dali::Toolkit::ProgressBar::Property *result = 0 ;
82600
82601   {
82602     try {
82603       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
82604     } catch (std::out_of_range& e) {
82605       {
82606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82607       };
82608     } catch (std::exception& e) {
82609       {
82610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82611       };
82612     } catch (...) {
82613       {
82614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82615       };
82616     }
82617   }
82618   jresult = (void *)result;
82619   return jresult;
82620 }
82621
82622
82623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
82624   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
82625
82626   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
82627   {
82628     try {
82629       delete arg1;
82630     } catch (std::out_of_range& e) {
82631       {
82632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82633       };
82634     } catch (std::exception& e) {
82635       {
82636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82637       };
82638     } catch (...) {
82639       {
82640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82641       };
82642     }
82643   }
82644 }
82645
82646
82647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
82648   void * jresult ;
82649   Dali::Toolkit::ProgressBar result;
82650
82651   {
82652     try {
82653       result = Dali::Toolkit::ProgressBar::New();
82654     } catch (std::out_of_range& e) {
82655       {
82656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82657       };
82658     } catch (std::exception& e) {
82659       {
82660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82661       };
82662     } catch (...) {
82663       {
82664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82665       };
82666     }
82667   }
82668   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
82669   return jresult;
82670 }
82671
82672
82673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
82674   void * jresult ;
82675   Dali::Toolkit::ProgressBar *result = 0 ;
82676
82677   {
82678     try {
82679       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
82680     } catch (std::out_of_range& e) {
82681       {
82682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82683       };
82684     } catch (std::exception& e) {
82685       {
82686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82687       };
82688     } catch (...) {
82689       {
82690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82691       };
82692     }
82693   }
82694   jresult = (void *)result;
82695   return jresult;
82696 }
82697
82698
82699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
82700   void * jresult ;
82701   Dali::Toolkit::ProgressBar *arg1 = 0 ;
82702   Dali::Toolkit::ProgressBar *result = 0 ;
82703
82704   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82705   if (!arg1) {
82706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
82707     return 0;
82708   }
82709   {
82710     try {
82711       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
82712     } catch (std::out_of_range& e) {
82713       {
82714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82715       };
82716     } catch (std::exception& e) {
82717       {
82718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82719       };
82720     } catch (...) {
82721       {
82722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82723       };
82724     }
82725   }
82726   jresult = (void *)result;
82727   return jresult;
82728 }
82729
82730
82731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
82732   void * jresult ;
82733   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
82734   Dali::Toolkit::ProgressBar *arg2 = 0 ;
82735   Dali::Toolkit::ProgressBar *result = 0 ;
82736
82737   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82738   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
82739   if (!arg2) {
82740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
82741     return 0;
82742   }
82743   {
82744     try {
82745       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
82746     } catch (std::out_of_range& e) {
82747       {
82748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82749       };
82750     } catch (std::exception& e) {
82751       {
82752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82753       };
82754     } catch (...) {
82755       {
82756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82757       };
82758     }
82759   }
82760   jresult = (void *)result;
82761   return jresult;
82762 }
82763
82764
82765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
82766   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
82767
82768   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82769   {
82770     try {
82771       delete arg1;
82772     } catch (std::out_of_range& e) {
82773       {
82774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82775       };
82776     } catch (std::exception& e) {
82777       {
82778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82779       };
82780     } catch (...) {
82781       {
82782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82783       };
82784     }
82785   }
82786 }
82787
82788
82789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
82790   void * jresult ;
82791   Dali::BaseHandle arg1 ;
82792   Dali::BaseHandle *argp1 ;
82793   Dali::Toolkit::ProgressBar result;
82794
82795   argp1 = (Dali::BaseHandle *)jarg1;
82796   if (!argp1) {
82797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82798     return 0;
82799   }
82800   arg1 = *argp1;
82801   {
82802     try {
82803       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
82804     } catch (std::out_of_range& e) {
82805       {
82806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82807       };
82808     } catch (std::exception& e) {
82809       {
82810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82811       };
82812     } catch (...) {
82813       {
82814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82815       };
82816     }
82817   }
82818   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
82819   return jresult;
82820 }
82821
82822
82823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
82824   void * jresult ;
82825   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
82826   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
82827
82828   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82829   {
82830     try {
82831       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
82832     } catch (std::out_of_range& e) {
82833       {
82834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82835       };
82836     } catch (std::exception& e) {
82837       {
82838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82839       };
82840     } catch (...) {
82841       {
82842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82843       };
82844     }
82845   }
82846   jresult = (void *)result;
82847   return jresult;
82848 }
82849
82850
82851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
82852   void * jresult ;
82853   Dali::Toolkit::GaussianBlurView *result = 0 ;
82854
82855   {
82856     try {
82857       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
82858     } catch (std::out_of_range& e) {
82859       {
82860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82861       };
82862     } catch (std::exception& e) {
82863       {
82864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82865       };
82866     } catch (...) {
82867       {
82868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82869       };
82870     }
82871   }
82872   jresult = (void *)result;
82873   return jresult;
82874 }
82875
82876
82877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
82878   void * jresult ;
82879   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
82880   Dali::Toolkit::GaussianBlurView *result = 0 ;
82881
82882   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82883   if (!arg1) {
82884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
82885     return 0;
82886   }
82887   {
82888     try {
82889       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
82890     } catch (std::out_of_range& e) {
82891       {
82892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82893       };
82894     } catch (std::exception& e) {
82895       {
82896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82897       };
82898     } catch (...) {
82899       {
82900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82901       };
82902     }
82903   }
82904   jresult = (void *)result;
82905   return jresult;
82906 }
82907
82908
82909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
82910   void * jresult ;
82911   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82912   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
82913   Dali::Toolkit::GaussianBlurView *result = 0 ;
82914
82915   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82916   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
82917   if (!arg2) {
82918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
82919     return 0;
82920   }
82921   {
82922     try {
82923       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
82924     } catch (std::out_of_range& e) {
82925       {
82926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82927       };
82928     } catch (std::exception& e) {
82929       {
82930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82931       };
82932     } catch (...) {
82933       {
82934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82935       };
82936     }
82937   }
82938   jresult = (void *)result;
82939   return jresult;
82940 }
82941
82942
82943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
82944   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82945
82946   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82947   {
82948     try {
82949       delete arg1;
82950     } catch (std::out_of_range& e) {
82951       {
82952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82953       };
82954     } catch (std::exception& e) {
82955       {
82956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82957       };
82958     } catch (...) {
82959       {
82960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82961       };
82962     }
82963   }
82964 }
82965
82966
82967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
82968   void * jresult ;
82969   Dali::BaseHandle arg1 ;
82970   Dali::BaseHandle *argp1 ;
82971   Dali::Toolkit::GaussianBlurView result;
82972
82973   argp1 = (Dali::BaseHandle *)jarg1;
82974   if (!argp1) {
82975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82976     return 0;
82977   }
82978   arg1 = *argp1;
82979   {
82980     try {
82981       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
82982     } catch (std::out_of_range& e) {
82983       {
82984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82985       };
82986     } catch (std::exception& e) {
82987       {
82988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82989       };
82990     } catch (...) {
82991       {
82992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82993       };
82994     }
82995   }
82996   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
82997   return jresult;
82998 }
82999
83000
83001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
83002   void * jresult ;
83003   Dali::Toolkit::GaussianBlurView result;
83004
83005   {
83006     try {
83007       result = Dali::Toolkit::GaussianBlurView::New();
83008     } catch (std::out_of_range& e) {
83009       {
83010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83011       };
83012     } catch (std::exception& e) {
83013       {
83014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83015       };
83016     } catch (...) {
83017       {
83018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83019       };
83020     }
83021   }
83022   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83023   return jresult;
83024 }
83025
83026
83027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
83028   void * jresult ;
83029   unsigned int arg1 ;
83030   float arg2 ;
83031   Dali::Pixel::Format arg3 ;
83032   float arg4 ;
83033   float arg5 ;
83034   bool arg6 ;
83035   Dali::Toolkit::GaussianBlurView result;
83036
83037   arg1 = (unsigned int)jarg1;
83038   arg2 = (float)jarg2;
83039   arg3 = (Dali::Pixel::Format)jarg3;
83040   arg4 = (float)jarg4;
83041   arg5 = (float)jarg5;
83042   arg6 = jarg6 ? true : false;
83043   {
83044     try {
83045       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
83046     } catch (std::out_of_range& e) {
83047       {
83048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83049       };
83050     } catch (std::exception& e) {
83051       {
83052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83053       };
83054     } catch (...) {
83055       {
83056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83057       };
83058     }
83059   }
83060   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83061   return jresult;
83062 }
83063
83064
83065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
83066   void * jresult ;
83067   unsigned int arg1 ;
83068   float arg2 ;
83069   Dali::Pixel::Format arg3 ;
83070   float arg4 ;
83071   float arg5 ;
83072   Dali::Toolkit::GaussianBlurView result;
83073
83074   arg1 = (unsigned int)jarg1;
83075   arg2 = (float)jarg2;
83076   arg3 = (Dali::Pixel::Format)jarg3;
83077   arg4 = (float)jarg4;
83078   arg5 = (float)jarg5;
83079   {
83080     try {
83081       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
83082     } catch (std::out_of_range& e) {
83083       {
83084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83085       };
83086     } catch (std::exception& e) {
83087       {
83088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83089       };
83090     } catch (...) {
83091       {
83092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83093       };
83094     }
83095   }
83096   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83097   return jresult;
83098 }
83099
83100
83101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
83102   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83103   Dali::Actor arg2 ;
83104   Dali::Actor *argp2 ;
83105
83106   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83107   argp2 = (Dali::Actor *)jarg2;
83108   if (!argp2) {
83109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83110     return ;
83111   }
83112   arg2 = *argp2;
83113   {
83114     try {
83115       (arg1)->Add(arg2);
83116     } catch (std::out_of_range& e) {
83117       {
83118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83119       };
83120     } catch (std::exception& e) {
83121       {
83122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83123       };
83124     } catch (...) {
83125       {
83126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83127       };
83128     }
83129   }
83130 }
83131
83132
83133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
83134   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83135   Dali::Actor arg2 ;
83136   Dali::Actor *argp2 ;
83137
83138   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83139   argp2 = (Dali::Actor *)jarg2;
83140   if (!argp2) {
83141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83142     return ;
83143   }
83144   arg2 = *argp2;
83145   {
83146     try {
83147       (arg1)->Remove(arg2);
83148     } catch (std::out_of_range& e) {
83149       {
83150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83151       };
83152     } catch (std::exception& e) {
83153       {
83154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83155       };
83156     } catch (...) {
83157       {
83158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83159       };
83160     }
83161   }
83162 }
83163
83164
83165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
83166   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83167
83168   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83169   {
83170     try {
83171       (arg1)->Activate();
83172     } catch (std::out_of_range& e) {
83173       {
83174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83175       };
83176     } catch (std::exception& e) {
83177       {
83178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83179       };
83180     } catch (...) {
83181       {
83182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83183       };
83184     }
83185   }
83186 }
83187
83188
83189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
83190   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83191
83192   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83193   {
83194     try {
83195       (arg1)->ActivateOnce();
83196     } catch (std::out_of_range& e) {
83197       {
83198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83199       };
83200     } catch (std::exception& e) {
83201       {
83202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83203       };
83204     } catch (...) {
83205       {
83206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83207       };
83208     }
83209   }
83210 }
83211
83212
83213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
83214   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83215
83216   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83217   {
83218     try {
83219       (arg1)->Deactivate();
83220     } catch (std::out_of_range& e) {
83221       {
83222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83223       };
83224     } catch (std::exception& e) {
83225       {
83226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83227       };
83228     } catch (...) {
83229       {
83230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83231       };
83232     }
83233   }
83234 }
83235
83236
83237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
83238   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83239   Dali::Image arg2 ;
83240   Dali::FrameBufferImage arg3 ;
83241   Dali::Image *argp2 ;
83242   Dali::FrameBufferImage *argp3 ;
83243
83244   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83245   argp2 = (Dali::Image *)jarg2;
83246   if (!argp2) {
83247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
83248     return ;
83249   }
83250   arg2 = *argp2;
83251   argp3 = (Dali::FrameBufferImage *)jarg3;
83252   if (!argp3) {
83253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
83254     return ;
83255   }
83256   arg3 = *argp3;
83257   {
83258     try {
83259       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
83260     } catch (std::out_of_range& e) {
83261       {
83262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83263       };
83264     } catch (std::exception& e) {
83265       {
83266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83267       };
83268     } catch (...) {
83269       {
83270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83271       };
83272     }
83273   }
83274 }
83275
83276
83277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
83278   int jresult ;
83279   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83280   Dali::Property::Index result;
83281
83282   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83283   {
83284     try {
83285       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
83286     } catch (std::out_of_range& e) {
83287       {
83288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83289       };
83290     } catch (std::exception& e) {
83291       {
83292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83293       };
83294     } catch (...) {
83295       {
83296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83297       };
83298     }
83299   }
83300   jresult = result;
83301   return jresult;
83302 }
83303
83304
83305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
83306   void * jresult ;
83307   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83308   Dali::FrameBufferImage result;
83309
83310   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83311   {
83312     try {
83313       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
83314     } catch (std::out_of_range& e) {
83315       {
83316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83317       };
83318     } catch (std::exception& e) {
83319       {
83320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83321       };
83322     } catch (...) {
83323       {
83324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83325       };
83326     }
83327   }
83328   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
83329   return jresult;
83330 }
83331
83332
83333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
83334   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83335   Dali::Vector4 *arg2 = 0 ;
83336
83337   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83338   arg2 = (Dali::Vector4 *)jarg2;
83339   if (!arg2) {
83340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
83341     return ;
83342   }
83343   {
83344     try {
83345       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
83346     } catch (std::out_of_range& e) {
83347       {
83348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83349       };
83350     } catch (std::exception& e) {
83351       {
83352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83353       };
83354     } catch (...) {
83355       {
83356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83357       };
83358     }
83359   }
83360 }
83361
83362
83363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
83364   void * jresult ;
83365   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83366   Dali::Vector4 result;
83367
83368   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83369   {
83370     try {
83371       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
83372     } catch (std::out_of_range& e) {
83373       {
83374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83375       };
83376     } catch (std::exception& e) {
83377       {
83378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83379       };
83380     } catch (...) {
83381       {
83382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83383       };
83384     }
83385   }
83386   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
83387   return jresult;
83388 }
83389
83390
83391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
83392   void * jresult ;
83393   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83394   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
83395
83396   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83397   {
83398     try {
83399       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
83400     } catch (std::out_of_range& e) {
83401       {
83402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83403       };
83404     } catch (std::exception& e) {
83405       {
83406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83407       };
83408     } catch (...) {
83409       {
83410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83411       };
83412     }
83413   }
83414   jresult = (void *)result;
83415   return jresult;
83416 }
83417
83418
83419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
83420   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
83421
83422   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83423   {
83424     try {
83425       delete arg1;
83426     } catch (std::out_of_range& e) {
83427       {
83428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83429       };
83430     } catch (std::exception& e) {
83431       {
83432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83433       };
83434     } catch (...) {
83435       {
83436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83437       };
83438     }
83439   }
83440 }
83441
83442
83443 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
83444   unsigned int jresult ;
83445   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
83446   unsigned int result;
83447
83448   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83449   {
83450     try {
83451       result = (unsigned int)(arg1)->GetNumberOfPages();
83452     } catch (std::out_of_range& e) {
83453       {
83454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83455       };
83456     } catch (std::exception& e) {
83457       {
83458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83459       };
83460     } catch (...) {
83461       {
83462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83463       };
83464     }
83465   }
83466   jresult = result;
83467   return jresult;
83468 }
83469
83470
83471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
83472   void * jresult ;
83473   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
83474   unsigned int arg2 ;
83475   Dali::Texture result;
83476
83477   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83478   arg2 = (unsigned int)jarg2;
83479   {
83480     try {
83481       result = (arg1)->NewPage(arg2);
83482     } catch (std::out_of_range& e) {
83483       {
83484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83485       };
83486     } catch (std::exception& e) {
83487       {
83488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83489       };
83490     } catch (...) {
83491       {
83492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83493       };
83494     }
83495   }
83496   jresult = new Dali::Texture((const Dali::Texture &)result);
83497   return jresult;
83498 }
83499
83500
83501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
83502   int jresult ;
83503   int result;
83504
83505   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
83506   jresult = (int)result;
83507   return jresult;
83508 }
83509
83510
83511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
83512   int jresult ;
83513   int result;
83514
83515   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
83516   jresult = (int)result;
83517   return jresult;
83518 }
83519
83520
83521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
83522   int jresult ;
83523   int result;
83524
83525   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
83526   jresult = (int)result;
83527   return jresult;
83528 }
83529
83530
83531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
83532   void * jresult ;
83533   Dali::Toolkit::PageTurnView::Property *result = 0 ;
83534
83535   {
83536     try {
83537       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
83538     } catch (std::out_of_range& e) {
83539       {
83540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83541       };
83542     } catch (std::exception& e) {
83543       {
83544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83545       };
83546     } catch (...) {
83547       {
83548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83549       };
83550     }
83551   }
83552   jresult = (void *)result;
83553   return jresult;
83554 }
83555
83556
83557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
83558   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
83559
83560   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
83561   {
83562     try {
83563       delete arg1;
83564     } catch (std::out_of_range& e) {
83565       {
83566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83567       };
83568     } catch (std::exception& e) {
83569       {
83570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83571       };
83572     } catch (...) {
83573       {
83574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83575       };
83576     }
83577   }
83578 }
83579
83580
83581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
83582   void * jresult ;
83583   Dali::Toolkit::PageTurnView *result = 0 ;
83584
83585   {
83586     try {
83587       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
83588     } catch (std::out_of_range& e) {
83589       {
83590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83591       };
83592     } catch (std::exception& e) {
83593       {
83594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83595       };
83596     } catch (...) {
83597       {
83598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83599       };
83600     }
83601   }
83602   jresult = (void *)result;
83603   return jresult;
83604 }
83605
83606
83607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
83608   void * jresult ;
83609   Dali::Toolkit::PageTurnView *arg1 = 0 ;
83610   Dali::Toolkit::PageTurnView *result = 0 ;
83611
83612   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83613   if (!arg1) {
83614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
83615     return 0;
83616   }
83617   {
83618     try {
83619       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
83620     } catch (std::out_of_range& e) {
83621       {
83622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83623       };
83624     } catch (std::exception& e) {
83625       {
83626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83627       };
83628     } catch (...) {
83629       {
83630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83631       };
83632     }
83633   }
83634   jresult = (void *)result;
83635   return jresult;
83636 }
83637
83638
83639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
83640   void * jresult ;
83641   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83642   Dali::Toolkit::PageTurnView *arg2 = 0 ;
83643   Dali::Toolkit::PageTurnView *result = 0 ;
83644
83645   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83646   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
83647   if (!arg2) {
83648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
83649     return 0;
83650   }
83651   {
83652     try {
83653       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
83654     } catch (std::out_of_range& e) {
83655       {
83656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83657       };
83658     } catch (std::exception& e) {
83659       {
83660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83661       };
83662     } catch (...) {
83663       {
83664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83665       };
83666     }
83667   }
83668   jresult = (void *)result;
83669   return jresult;
83670 }
83671
83672
83673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
83674   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83675
83676   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83677   {
83678     try {
83679       delete arg1;
83680     } catch (std::out_of_range& e) {
83681       {
83682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83683       };
83684     } catch (std::exception& e) {
83685       {
83686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83687       };
83688     } catch (...) {
83689       {
83690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83691       };
83692     }
83693   }
83694 }
83695
83696
83697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
83698   void * jresult ;
83699   Dali::BaseHandle arg1 ;
83700   Dali::BaseHandle *argp1 ;
83701   Dali::Toolkit::PageTurnView result;
83702
83703   argp1 = (Dali::BaseHandle *)jarg1;
83704   if (!argp1) {
83705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83706     return 0;
83707   }
83708   arg1 = *argp1;
83709   {
83710     try {
83711       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
83712     } catch (std::out_of_range& e) {
83713       {
83714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83715       };
83716     } catch (std::exception& e) {
83717       {
83718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83719       };
83720     } catch (...) {
83721       {
83722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83723       };
83724     }
83725   }
83726   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
83727   return jresult;
83728 }
83729
83730
83731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
83732   void * jresult ;
83733   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83734   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
83735
83736   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83737   {
83738     try {
83739       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
83740     } catch (std::out_of_range& e) {
83741       {
83742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83743       };
83744     } catch (std::exception& e) {
83745       {
83746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83747       };
83748     } catch (...) {
83749       {
83750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83751       };
83752     }
83753   }
83754   jresult = (void *)result;
83755   return jresult;
83756 }
83757
83758
83759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
83760   void * jresult ;
83761   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83762   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
83763
83764   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83765   {
83766     try {
83767       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
83768     } catch (std::out_of_range& e) {
83769       {
83770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83771       };
83772     } catch (std::exception& e) {
83773       {
83774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83775       };
83776     } catch (...) {
83777       {
83778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83779       };
83780     }
83781   }
83782   jresult = (void *)result;
83783   return jresult;
83784 }
83785
83786
83787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
83788   void * jresult ;
83789   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83790   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
83791
83792   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83793   {
83794     try {
83795       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
83796     } catch (std::out_of_range& e) {
83797       {
83798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83799       };
83800     } catch (std::exception& e) {
83801       {
83802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83803       };
83804     } catch (...) {
83805       {
83806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83807       };
83808     }
83809   }
83810   jresult = (void *)result;
83811   return jresult;
83812 }
83813
83814
83815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
83816   void * jresult ;
83817   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83818   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
83819
83820   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83821   {
83822     try {
83823       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
83824     } catch (std::out_of_range& e) {
83825       {
83826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83827       };
83828     } catch (std::exception& e) {
83829       {
83830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83831       };
83832     } catch (...) {
83833       {
83834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83835       };
83836     }
83837   }
83838   jresult = (void *)result;
83839   return jresult;
83840 }
83841
83842
83843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
83844   void * jresult ;
83845   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
83846
83847   {
83848     try {
83849       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
83850     } catch (std::out_of_range& e) {
83851       {
83852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83853       };
83854     } catch (std::exception& e) {
83855       {
83856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83857       };
83858     } catch (...) {
83859       {
83860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83861       };
83862     }
83863   }
83864   jresult = (void *)result;
83865   return jresult;
83866 }
83867
83868
83869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
83870   void * jresult ;
83871   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
83872   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
83873
83874   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
83875   if (!arg1) {
83876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
83877     return 0;
83878   }
83879   {
83880     try {
83881       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
83882     } catch (std::out_of_range& e) {
83883       {
83884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83885       };
83886     } catch (std::exception& e) {
83887       {
83888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83889       };
83890     } catch (...) {
83891       {
83892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83893       };
83894     }
83895   }
83896   jresult = (void *)result;
83897   return jresult;
83898 }
83899
83900
83901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
83902   void * jresult ;
83903   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
83904   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
83905   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
83906
83907   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
83908   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
83909   if (!arg2) {
83910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
83911     return 0;
83912   }
83913   {
83914     try {
83915       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
83916     } catch (std::out_of_range& e) {
83917       {
83918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83919       };
83920     } catch (std::exception& e) {
83921       {
83922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83923       };
83924     } catch (...) {
83925       {
83926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83927       };
83928     }
83929   }
83930   jresult = (void *)result;
83931   return jresult;
83932 }
83933
83934
83935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
83936   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
83937
83938   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
83939   {
83940     try {
83941       delete arg1;
83942     } catch (std::out_of_range& e) {
83943       {
83944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83945       };
83946     } catch (std::exception& e) {
83947       {
83948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83949       };
83950     } catch (...) {
83951       {
83952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83953       };
83954     }
83955   }
83956 }
83957
83958
83959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
83960   void * jresult ;
83961   Dali::Toolkit::PageFactory *arg1 = 0 ;
83962   Dali::Vector2 *arg2 = 0 ;
83963   Dali::Toolkit::PageTurnLandscapeView result;
83964
83965   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83966   if (!arg1) {
83967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
83968     return 0;
83969   }
83970   arg2 = (Dali::Vector2 *)jarg2;
83971   if (!arg2) {
83972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
83973     return 0;
83974   }
83975   {
83976     try {
83977       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
83978     } catch (std::out_of_range& e) {
83979       {
83980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83981       };
83982     } catch (std::exception& e) {
83983       {
83984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83985       };
83986     } catch (...) {
83987       {
83988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83989       };
83990     }
83991   }
83992   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
83993   return jresult;
83994 }
83995
83996
83997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
83998   void * jresult ;
83999   Dali::BaseHandle arg1 ;
84000   Dali::BaseHandle *argp1 ;
84001   Dali::Toolkit::PageTurnLandscapeView result;
84002
84003   argp1 = (Dali::BaseHandle *)jarg1;
84004   if (!argp1) {
84005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84006     return 0;
84007   }
84008   arg1 = *argp1;
84009   {
84010     try {
84011       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
84012     } catch (std::out_of_range& e) {
84013       {
84014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84015       };
84016     } catch (std::exception& e) {
84017       {
84018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84019       };
84020     } catch (...) {
84021       {
84022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84023       };
84024     }
84025   }
84026   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
84027   return jresult;
84028 }
84029
84030
84031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
84032   void * jresult ;
84033   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
84034
84035   {
84036     try {
84037       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
84038     } catch (std::out_of_range& e) {
84039       {
84040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84041       };
84042     } catch (std::exception& e) {
84043       {
84044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84045       };
84046     } catch (...) {
84047       {
84048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84049       };
84050     }
84051   }
84052   jresult = (void *)result;
84053   return jresult;
84054 }
84055
84056
84057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
84058   void * jresult ;
84059   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
84060   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
84061
84062   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
84063   if (!arg1) {
84064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
84065     return 0;
84066   }
84067   {
84068     try {
84069       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
84070     } catch (std::out_of_range& e) {
84071       {
84072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84073       };
84074     } catch (std::exception& e) {
84075       {
84076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84077       };
84078     } catch (...) {
84079       {
84080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84081       };
84082     }
84083   }
84084   jresult = (void *)result;
84085   return jresult;
84086 }
84087
84088
84089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
84090   void * jresult ;
84091   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
84092   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
84093   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
84094
84095   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
84096   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
84097   if (!arg2) {
84098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
84099     return 0;
84100   }
84101   {
84102     try {
84103       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
84104     } catch (std::out_of_range& e) {
84105       {
84106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84107       };
84108     } catch (std::exception& e) {
84109       {
84110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84111       };
84112     } catch (...) {
84113       {
84114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84115       };
84116     }
84117   }
84118   jresult = (void *)result;
84119   return jresult;
84120 }
84121
84122
84123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
84124   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
84125
84126   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
84127   {
84128     try {
84129       delete arg1;
84130     } catch (std::out_of_range& e) {
84131       {
84132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84133       };
84134     } catch (std::exception& e) {
84135       {
84136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84137       };
84138     } catch (...) {
84139       {
84140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84141       };
84142     }
84143   }
84144 }
84145
84146
84147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
84148   void * jresult ;
84149   Dali::Toolkit::PageFactory *arg1 = 0 ;
84150   Dali::Vector2 *arg2 = 0 ;
84151   Dali::Toolkit::PageTurnPortraitView result;
84152
84153   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84154   if (!arg1) {
84155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
84156     return 0;
84157   }
84158   arg2 = (Dali::Vector2 *)jarg2;
84159   if (!arg2) {
84160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
84161     return 0;
84162   }
84163   {
84164     try {
84165       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
84166     } catch (std::out_of_range& e) {
84167       {
84168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84169       };
84170     } catch (std::exception& e) {
84171       {
84172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84173       };
84174     } catch (...) {
84175       {
84176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84177       };
84178     }
84179   }
84180   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
84181   return jresult;
84182 }
84183
84184
84185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
84186   void * jresult ;
84187   Dali::BaseHandle arg1 ;
84188   Dali::BaseHandle *argp1 ;
84189   Dali::Toolkit::PageTurnPortraitView result;
84190
84191   argp1 = (Dali::BaseHandle *)jarg1;
84192   if (!argp1) {
84193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84194     return 0;
84195   }
84196   arg1 = *argp1;
84197   {
84198     try {
84199       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
84200     } catch (std::out_of_range& e) {
84201       {
84202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84203       };
84204     } catch (std::exception& e) {
84205       {
84206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84207       };
84208     } catch (...) {
84209       {
84210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84211       };
84212     }
84213   }
84214   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
84215   return jresult;
84216 }
84217
84218
84219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
84220   int jresult ;
84221   int result;
84222
84223   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
84224   jresult = (int)result;
84225   return jresult;
84226 }
84227
84228
84229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
84230   int jresult ;
84231   int result;
84232
84233   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
84234   jresult = (int)result;
84235   return jresult;
84236 }
84237
84238
84239 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
84240   int jresult ;
84241   int result;
84242
84243   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
84244   jresult = (int)result;
84245   return jresult;
84246 }
84247
84248
84249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
84250   void * jresult ;
84251   Dali::Toolkit::ToggleButton::Property *result = 0 ;
84252
84253   {
84254     try {
84255       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
84256     } catch (std::out_of_range& e) {
84257       {
84258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84259       };
84260     } catch (std::exception& e) {
84261       {
84262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84263       };
84264     } catch (...) {
84265       {
84266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84267       };
84268     }
84269   }
84270   jresult = (void *)result;
84271   return jresult;
84272 }
84273
84274
84275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
84276   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
84277
84278   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
84279   {
84280     try {
84281       delete arg1;
84282     } catch (std::out_of_range& e) {
84283       {
84284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84285       };
84286     } catch (std::exception& e) {
84287       {
84288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84289       };
84290     } catch (...) {
84291       {
84292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84293       };
84294     }
84295   }
84296 }
84297
84298
84299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
84300   void * jresult ;
84301   Dali::Toolkit::ToggleButton *result = 0 ;
84302
84303   {
84304     try {
84305       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
84306     } catch (std::out_of_range& e) {
84307       {
84308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84309       };
84310     } catch (std::exception& e) {
84311       {
84312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84313       };
84314     } catch (...) {
84315       {
84316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84317       };
84318     }
84319   }
84320   jresult = (void *)result;
84321   return jresult;
84322 }
84323
84324
84325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
84326   void * jresult ;
84327   Dali::Toolkit::ToggleButton *arg1 = 0 ;
84328   Dali::Toolkit::ToggleButton *result = 0 ;
84329
84330   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
84331   if (!arg1) {
84332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
84333     return 0;
84334   }
84335   {
84336     try {
84337       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
84338     } catch (std::out_of_range& e) {
84339       {
84340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84341       };
84342     } catch (std::exception& e) {
84343       {
84344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84345       };
84346     } catch (...) {
84347       {
84348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84349       };
84350     }
84351   }
84352   jresult = (void *)result;
84353   return jresult;
84354 }
84355
84356
84357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
84358   void * jresult ;
84359   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
84360   Dali::Toolkit::ToggleButton *arg2 = 0 ;
84361   Dali::Toolkit::ToggleButton *result = 0 ;
84362
84363   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
84364   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
84365   if (!arg2) {
84366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
84367     return 0;
84368   }
84369   {
84370     try {
84371       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
84372     } catch (std::out_of_range& e) {
84373       {
84374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84375       };
84376     } catch (std::exception& e) {
84377       {
84378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84379       };
84380     } catch (...) {
84381       {
84382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84383       };
84384     }
84385   }
84386   jresult = (void *)result;
84387   return jresult;
84388 }
84389
84390
84391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
84392   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
84393
84394   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
84395   {
84396     try {
84397       delete arg1;
84398     } catch (std::out_of_range& e) {
84399       {
84400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84401       };
84402     } catch (std::exception& e) {
84403       {
84404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84405       };
84406     } catch (...) {
84407       {
84408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84409       };
84410     }
84411   }
84412 }
84413
84414
84415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
84416   void * jresult ;
84417   Dali::Toolkit::ToggleButton result;
84418
84419   {
84420     try {
84421       result = Dali::Toolkit::ToggleButton::New();
84422     } catch (std::out_of_range& e) {
84423       {
84424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84425       };
84426     } catch (std::exception& e) {
84427       {
84428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84429       };
84430     } catch (...) {
84431       {
84432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84433       };
84434     }
84435   }
84436   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
84437   return jresult;
84438 }
84439
84440
84441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
84442   void * jresult ;
84443   Dali::BaseHandle arg1 ;
84444   Dali::BaseHandle *argp1 ;
84445   Dali::Toolkit::ToggleButton result;
84446
84447   argp1 = (Dali::BaseHandle *)jarg1;
84448   if (!argp1) {
84449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84450     return 0;
84451   }
84452   arg1 = *argp1;
84453   {
84454     try {
84455       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
84456     } catch (std::out_of_range& e) {
84457       {
84458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84459       };
84460     } catch (std::exception& e) {
84461       {
84462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84463       };
84464     } catch (...) {
84465       {
84466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84467       };
84468     }
84469   }
84470   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
84471   return jresult;
84472 }
84473
84474
84475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
84476   void * jresult ;
84477   Dali::Toolkit::Visual::Base *result = 0 ;
84478
84479   {
84480     try {
84481       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
84482     } catch (std::out_of_range& e) {
84483       {
84484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84485       };
84486     } catch (std::exception& e) {
84487       {
84488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84489       };
84490     } catch (...) {
84491       {
84492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84493       };
84494     }
84495   }
84496   jresult = (void *)result;
84497   return jresult;
84498 }
84499
84500
84501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
84502   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84503
84504   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84505   {
84506     try {
84507       delete arg1;
84508     } catch (std::out_of_range& e) {
84509       {
84510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84511       };
84512     } catch (std::exception& e) {
84513       {
84514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84515       };
84516     } catch (...) {
84517       {
84518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84519       };
84520     }
84521   }
84522 }
84523
84524
84525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
84526   void * jresult ;
84527   Dali::Toolkit::Visual::Base *arg1 = 0 ;
84528   Dali::Toolkit::Visual::Base *result = 0 ;
84529
84530   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84531   if (!arg1) {
84532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
84533     return 0;
84534   }
84535   {
84536     try {
84537       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
84538     } catch (std::out_of_range& e) {
84539       {
84540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84541       };
84542     } catch (std::exception& e) {
84543       {
84544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84545       };
84546     } catch (...) {
84547       {
84548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84549       };
84550     }
84551   }
84552   jresult = (void *)result;
84553   return jresult;
84554 }
84555
84556
84557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
84558   void * jresult ;
84559   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84560   Dali::Toolkit::Visual::Base *arg2 = 0 ;
84561   Dali::Toolkit::Visual::Base *result = 0 ;
84562
84563   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84564   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
84565   if (!arg2) {
84566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
84567     return 0;
84568   }
84569   {
84570     try {
84571       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
84572     } catch (std::out_of_range& e) {
84573       {
84574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84575       };
84576     } catch (std::exception& e) {
84577       {
84578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84579       };
84580     } catch (...) {
84581       {
84582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84583       };
84584     }
84585   }
84586   jresult = (void *)result;
84587   return jresult;
84588 }
84589
84590
84591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
84592   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84593   std::string *arg2 = 0 ;
84594
84595   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84596   if (!jarg2) {
84597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84598     return ;
84599   }
84600   std::string arg2_str(jarg2);
84601   arg2 = &arg2_str;
84602   {
84603     try {
84604       (arg1)->SetName((std::string const &)*arg2);
84605     } catch (std::out_of_range& e) {
84606       {
84607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84608       };
84609     } catch (std::exception& e) {
84610       {
84611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84612       };
84613     } catch (...) {
84614       {
84615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84616       };
84617     }
84618   }
84619
84620   //argout typemap for const std::string&
84621
84622 }
84623
84624
84625 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
84626   char * jresult ;
84627   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84628   std::string *result = 0 ;
84629
84630   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84631   {
84632     try {
84633       result = (std::string *) &(arg1)->GetName();
84634     } catch (std::out_of_range& e) {
84635       {
84636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84637       };
84638     } catch (std::exception& e) {
84639       {
84640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84641       };
84642     } catch (...) {
84643       {
84644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84645       };
84646     }
84647   }
84648   jresult = SWIG_csharp_string_callback(result->c_str());
84649   return jresult;
84650 }
84651
84652
84653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
84654   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84655   Dali::Property::Map *arg2 = 0 ;
84656   Dali::Size arg3 ;
84657   Dali::Size *argp3 ;
84658
84659   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84660   arg2 = (Dali::Property::Map *)jarg2;
84661   if (!arg2) {
84662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
84663     return ;
84664   }
84665   argp3 = (Dali::Size *)jarg3;
84666   if (!argp3) {
84667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
84668     return ;
84669   }
84670   arg3 = *argp3;
84671   {
84672     try {
84673       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
84674     } catch (std::out_of_range& e) {
84675       {
84676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84677       };
84678     } catch (std::exception& e) {
84679       {
84680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84681       };
84682     } catch (...) {
84683       {
84684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84685       };
84686     }
84687   }
84688 }
84689
84690
84691 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
84692   float jresult ;
84693   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84694   float arg2 ;
84695   float result;
84696
84697   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84698   arg2 = (float)jarg2;
84699   {
84700     try {
84701       result = (float)(arg1)->GetHeightForWidth(arg2);
84702     } catch (std::out_of_range& e) {
84703       {
84704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84705       };
84706     } catch (std::exception& e) {
84707       {
84708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84709       };
84710     } catch (...) {
84711       {
84712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84713       };
84714     }
84715   }
84716   jresult = result;
84717   return jresult;
84718 }
84719
84720
84721 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
84722   float jresult ;
84723   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84724   float arg2 ;
84725   float result;
84726
84727   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84728   arg2 = (float)jarg2;
84729   {
84730     try {
84731       result = (float)(arg1)->GetWidthForHeight(arg2);
84732     } catch (std::out_of_range& e) {
84733       {
84734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84735       };
84736     } catch (std::exception& e) {
84737       {
84738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84739       };
84740     } catch (...) {
84741       {
84742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84743       };
84744     }
84745   }
84746   jresult = result;
84747   return jresult;
84748 }
84749
84750
84751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
84752   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84753   Dali::Vector2 *arg2 = 0 ;
84754
84755   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84756   arg2 = (Dali::Vector2 *)jarg2;
84757   if (!arg2) {
84758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
84759     return ;
84760   }
84761   {
84762     try {
84763       (arg1)->GetNaturalSize(*arg2);
84764     } catch (std::out_of_range& e) {
84765       {
84766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84767       };
84768     } catch (std::exception& e) {
84769       {
84770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84771       };
84772     } catch (...) {
84773       {
84774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84775       };
84776     }
84777   }
84778 }
84779
84780
84781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, float jarg2) {
84782   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84783   float arg2 ;
84784
84785   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84786   arg2 = (float)jarg2;
84787   {
84788     try {
84789       (arg1)->SetDepthIndex(arg2);
84790     } catch (std::out_of_range& e) {
84791       {
84792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84793       };
84794     } catch (std::exception& e) {
84795       {
84796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84797       };
84798     } catch (...) {
84799       {
84800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84801       };
84802     }
84803   }
84804 }
84805
84806
84807 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
84808   float jresult ;
84809   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84810   float result;
84811
84812   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84813   {
84814     try {
84815       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
84816     } catch (std::out_of_range& e) {
84817       {
84818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84819       };
84820     } catch (std::exception& e) {
84821       {
84822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84823       };
84824     } catch (...) {
84825       {
84826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84827       };
84828     }
84829   }
84830   jresult = result;
84831   return jresult;
84832 }
84833
84834
84835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
84836   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84837   Dali::Property::Map *arg2 = 0 ;
84838
84839   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84840   arg2 = (Dali::Property::Map *)jarg2;
84841   if (!arg2) {
84842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
84843     return ;
84844   }
84845   {
84846     try {
84847       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
84848     } catch (std::out_of_range& e) {
84849       {
84850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84851       };
84852     } catch (std::exception& e) {
84853       {
84854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84855       };
84856     } catch (...) {
84857       {
84858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84859       };
84860     }
84861   }
84862 }
84863
84864
84865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
84866   void * jresult ;
84867   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
84868   Dali::Toolkit::Visual::Base *result = 0 ;
84869
84870   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
84871   {
84872     try {
84873       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
84874     } catch (std::out_of_range& e) {
84875       {
84876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84877       };
84878     } catch (std::exception& e) {
84879       {
84880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84881       };
84882     } catch (...) {
84883       {
84884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84885       };
84886     }
84887   }
84888   jresult = (void *)result;
84889   return jresult;
84890 }
84891
84892
84893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
84894   void * jresult ;
84895   Dali::Toolkit::VisualFactory result;
84896
84897   {
84898     try {
84899       result = Dali::Toolkit::VisualFactory::Get();
84900     } catch (std::out_of_range& e) {
84901       {
84902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84903       };
84904     } catch (std::exception& e) {
84905       {
84906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84907       };
84908     } catch (...) {
84909       {
84910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84911       };
84912     }
84913   }
84914   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
84915   return jresult;
84916 }
84917
84918
84919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
84920   void * jresult ;
84921   Dali::Toolkit::VisualFactory *result = 0 ;
84922
84923   {
84924     try {
84925       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
84926     } catch (std::out_of_range& e) {
84927       {
84928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84929       };
84930     } catch (std::exception& e) {
84931       {
84932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84933       };
84934     } catch (...) {
84935       {
84936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84937       };
84938     }
84939   }
84940   jresult = (void *)result;
84941   return jresult;
84942 }
84943
84944
84945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
84946   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84947
84948   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84949   {
84950     try {
84951       delete arg1;
84952     } catch (std::out_of_range& e) {
84953       {
84954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84955       };
84956     } catch (std::exception& e) {
84957       {
84958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84959       };
84960     } catch (...) {
84961       {
84962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84963       };
84964     }
84965   }
84966 }
84967
84968
84969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
84970   void * jresult ;
84971   Dali::Toolkit::VisualFactory *arg1 = 0 ;
84972   Dali::Toolkit::VisualFactory *result = 0 ;
84973
84974   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84975   if (!arg1) {
84976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
84977     return 0;
84978   }
84979   {
84980     try {
84981       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
84982     } catch (std::out_of_range& e) {
84983       {
84984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84985       };
84986     } catch (std::exception& e) {
84987       {
84988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84989       };
84990     } catch (...) {
84991       {
84992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84993       };
84994     }
84995   }
84996   jresult = (void *)result;
84997   return jresult;
84998 }
84999
85000
85001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
85002   void * jresult ;
85003   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85004   Dali::Toolkit::VisualFactory *arg2 = 0 ;
85005   Dali::Toolkit::VisualFactory *result = 0 ;
85006
85007   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85008   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
85009   if (!arg2) {
85010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
85011     return 0;
85012   }
85013   {
85014     try {
85015       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
85016     } catch (std::out_of_range& e) {
85017       {
85018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85019       };
85020     } catch (std::exception& e) {
85021       {
85022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85023       };
85024     } catch (...) {
85025       {
85026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85027       };
85028     }
85029   }
85030   jresult = (void *)result;
85031   return jresult;
85032 }
85033
85034
85035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
85036   void * jresult ;
85037   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85038   Dali::Property::Map *arg2 = 0 ;
85039   Dali::Toolkit::Visual::Base result;
85040
85041   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85042   arg2 = (Dali::Property::Map *)jarg2;
85043   if (!arg2) {
85044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
85045     return 0;
85046   }
85047   {
85048     try {
85049       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
85050     } catch (std::out_of_range& e) {
85051       {
85052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85053       };
85054     } catch (std::exception& e) {
85055       {
85056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85057       };
85058     } catch (...) {
85059       {
85060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85061       };
85062     }
85063   }
85064   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
85065   return jresult;
85066 }
85067
85068
85069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
85070   void * jresult ;
85071   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85072   Dali::Image *arg2 = 0 ;
85073   Dali::Toolkit::Visual::Base result;
85074
85075   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85076   arg2 = (Dali::Image *)jarg2;
85077   if (!arg2) {
85078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
85079     return 0;
85080   }
85081   {
85082     try {
85083       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
85084     } catch (std::out_of_range& e) {
85085       {
85086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85087       };
85088     } catch (std::exception& e) {
85089       {
85090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85091       };
85092     } catch (...) {
85093       {
85094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85095       };
85096     }
85097   }
85098   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
85099   return jresult;
85100 }
85101
85102
85103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
85104   void * jresult ;
85105   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85106   std::string *arg2 = 0 ;
85107   Dali::ImageDimensions arg3 ;
85108   Dali::ImageDimensions *argp3 ;
85109   Dali::Toolkit::Visual::Base result;
85110
85111   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85112   if (!jarg2) {
85113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85114     return 0;
85115   }
85116   std::string arg2_str(jarg2);
85117   arg2 = &arg2_str;
85118   argp3 = (Dali::ImageDimensions *)jarg3;
85119   if (!argp3) {
85120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85121     return 0;
85122   }
85123   arg3 = *argp3;
85124   {
85125     try {
85126       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
85127     } catch (std::out_of_range& e) {
85128       {
85129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85130       };
85131     } catch (std::exception& e) {
85132       {
85133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85134       };
85135     } catch (...) {
85136       {
85137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85138       };
85139     }
85140   }
85141   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
85142
85143   //argout typemap for const std::string&
85144
85145   return jresult;
85146 }
85147
85148
85149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
85150   void * jresult ;
85151   Dali::Toolkit::AsyncImageLoader *result = 0 ;
85152
85153   {
85154     try {
85155       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
85156     } catch (std::out_of_range& e) {
85157       {
85158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85159       };
85160     } catch (std::exception& e) {
85161       {
85162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85163       };
85164     } catch (...) {
85165       {
85166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85167       };
85168     }
85169   }
85170   jresult = (void *)result;
85171   return jresult;
85172 }
85173
85174
85175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
85176   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85177
85178   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85179   {
85180     try {
85181       delete arg1;
85182     } catch (std::out_of_range& e) {
85183       {
85184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85185       };
85186     } catch (std::exception& e) {
85187       {
85188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85189       };
85190     } catch (...) {
85191       {
85192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85193       };
85194     }
85195   }
85196 }
85197
85198
85199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
85200   void * jresult ;
85201   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
85202   Dali::Toolkit::AsyncImageLoader *result = 0 ;
85203
85204   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85205   if (!arg1) {
85206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
85207     return 0;
85208   }
85209   {
85210     try {
85211       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
85212     } catch (std::out_of_range& e) {
85213       {
85214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85215       };
85216     } catch (std::exception& e) {
85217       {
85218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85219       };
85220     } catch (...) {
85221       {
85222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85223       };
85224     }
85225   }
85226   jresult = (void *)result;
85227   return jresult;
85228 }
85229
85230
85231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
85232   void * jresult ;
85233   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85234   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
85235   Dali::Toolkit::AsyncImageLoader *result = 0 ;
85236
85237   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85238   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
85239   if (!arg2) {
85240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
85241     return 0;
85242   }
85243   {
85244     try {
85245       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
85246     } catch (std::out_of_range& e) {
85247       {
85248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85249       };
85250     } catch (std::exception& e) {
85251       {
85252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85253       };
85254     } catch (...) {
85255       {
85256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85257       };
85258     }
85259   }
85260   jresult = (void *)result;
85261   return jresult;
85262 }
85263
85264
85265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
85266   void * jresult ;
85267   Dali::Toolkit::AsyncImageLoader result;
85268
85269   {
85270     try {
85271       result = Dali::Toolkit::AsyncImageLoader::New();
85272     } catch (std::out_of_range& e) {
85273       {
85274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85275       };
85276     } catch (std::exception& e) {
85277       {
85278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85279       };
85280     } catch (...) {
85281       {
85282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85283       };
85284     }
85285   }
85286   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
85287   return jresult;
85288 }
85289
85290
85291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
85292   void * jresult ;
85293   Dali::BaseHandle arg1 ;
85294   Dali::BaseHandle *argp1 ;
85295   Dali::Toolkit::AsyncImageLoader result;
85296
85297   argp1 = (Dali::BaseHandle *)jarg1;
85298   if (!argp1) {
85299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85300     return 0;
85301   }
85302   arg1 = *argp1;
85303   {
85304     try {
85305       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
85306     } catch (std::out_of_range& e) {
85307       {
85308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85309       };
85310     } catch (std::exception& e) {
85311       {
85312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85313       };
85314     } catch (...) {
85315       {
85316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85317       };
85318     }
85319   }
85320   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
85321   return jresult;
85322 }
85323
85324
85325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
85326   unsigned int jresult ;
85327   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85328   std::string *arg2 = 0 ;
85329   uint32_t result;
85330
85331   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85332   if (!jarg2) {
85333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85334     return 0;
85335   }
85336   std::string arg2_str(jarg2);
85337   arg2 = &arg2_str;
85338   {
85339     try {
85340       result = (arg1)->Load((std::string const &)*arg2);
85341     } catch (std::out_of_range& e) {
85342       {
85343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85344       };
85345     } catch (std::exception& e) {
85346       {
85347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85348       };
85349     } catch (...) {
85350       {
85351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85352       };
85353     }
85354   }
85355   jresult = result;
85356
85357   //argout typemap for const std::string&
85358
85359   return jresult;
85360 }
85361
85362
85363 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
85364   unsigned int jresult ;
85365   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85366   std::string *arg2 = 0 ;
85367   Dali::ImageDimensions arg3 ;
85368   Dali::ImageDimensions *argp3 ;
85369   uint32_t result;
85370
85371   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85372   if (!jarg2) {
85373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85374     return 0;
85375   }
85376   std::string arg2_str(jarg2);
85377   arg2 = &arg2_str;
85378   argp3 = (Dali::ImageDimensions *)jarg3;
85379   if (!argp3) {
85380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85381     return 0;
85382   }
85383   arg3 = *argp3;
85384   {
85385     try {
85386       result = (arg1)->Load((std::string const &)*arg2,arg3);
85387     } catch (std::out_of_range& e) {
85388       {
85389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85390       };
85391     } catch (std::exception& e) {
85392       {
85393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85394       };
85395     } catch (...) {
85396       {
85397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85398       };
85399     }
85400   }
85401   jresult = result;
85402
85403   //argout typemap for const std::string&
85404
85405   return jresult;
85406 }
85407
85408
85409 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
85410   unsigned int jresult ;
85411   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85412   std::string *arg2 = 0 ;
85413   Dali::ImageDimensions arg3 ;
85414   Dali::FittingMode::Type arg4 ;
85415   Dali::SamplingMode::Type arg5 ;
85416   bool arg6 ;
85417   Dali::ImageDimensions *argp3 ;
85418   uint32_t result;
85419
85420   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85421   if (!jarg2) {
85422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85423     return 0;
85424   }
85425   std::string arg2_str(jarg2);
85426   arg2 = &arg2_str;
85427   argp3 = (Dali::ImageDimensions *)jarg3;
85428   if (!argp3) {
85429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85430     return 0;
85431   }
85432   arg3 = *argp3;
85433   arg4 = (Dali::FittingMode::Type)jarg4;
85434   arg5 = (Dali::SamplingMode::Type)jarg5;
85435   arg6 = jarg6 ? true : false;
85436   {
85437     try {
85438       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
85439     } catch (std::out_of_range& e) {
85440       {
85441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85442       };
85443     } catch (std::exception& e) {
85444       {
85445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85446       };
85447     } catch (...) {
85448       {
85449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85450       };
85451     }
85452   }
85453   jresult = result;
85454
85455   //argout typemap for const std::string&
85456
85457   return jresult;
85458 }
85459
85460
85461 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
85462   unsigned int jresult ;
85463   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85464   uint32_t arg2 ;
85465   bool result;
85466
85467   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85468   arg2 = (uint32_t)jarg2;
85469   {
85470     try {
85471       result = (bool)(arg1)->Cancel(arg2);
85472     } catch (std::out_of_range& e) {
85473       {
85474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85475       };
85476     } catch (std::exception& e) {
85477       {
85478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85479       };
85480     } catch (...) {
85481       {
85482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85483       };
85484     }
85485   }
85486   jresult = result;
85487   return jresult;
85488 }
85489
85490
85491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
85492   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85493
85494   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85495   {
85496     try {
85497       (arg1)->CancelAll();
85498     } catch (std::out_of_range& e) {
85499       {
85500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85501       };
85502     } catch (std::exception& e) {
85503       {
85504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85505       };
85506     } catch (...) {
85507       {
85508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85509       };
85510     }
85511   }
85512 }
85513
85514
85515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
85516   void * jresult ;
85517   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85518   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
85519
85520   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85521   {
85522     try {
85523       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
85524     } catch (std::out_of_range& e) {
85525       {
85526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85527       };
85528     } catch (std::exception& e) {
85529       {
85530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85531       };
85532     } catch (...) {
85533       {
85534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85535       };
85536     }
85537   }
85538   jresult = (void *)result;
85539   return jresult;
85540 }
85541
85542
85543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
85544   void * jresult ;
85545   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
85546   Dali::Toolkit::AsyncImageLoader *result = 0 ;
85547
85548   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
85549   {
85550     try {
85551       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
85552     } catch (std::out_of_range& e) {
85553       {
85554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85555       };
85556     } catch (std::exception& e) {
85557       {
85558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85559       };
85560     } catch (...) {
85561       {
85562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85563       };
85564     }
85565   }
85566   jresult = (void *)result;
85567   return jresult;
85568 }
85569
85570
85571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
85572   void * jresult ;
85573   std::string *arg1 = 0 ;
85574   Dali::PixelData result;
85575
85576   if (!jarg1) {
85577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85578     return 0;
85579   }
85580   std::string arg1_str(jarg1);
85581   arg1 = &arg1_str;
85582   {
85583     try {
85584       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
85585     } catch (std::out_of_range& e) {
85586       {
85587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85588       };
85589     } catch (std::exception& e) {
85590       {
85591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85592       };
85593     } catch (...) {
85594       {
85595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85596       };
85597     }
85598   }
85599   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85600
85601   //argout typemap for const std::string&
85602
85603   return jresult;
85604 }
85605
85606
85607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
85608   void * jresult ;
85609   std::string *arg1 = 0 ;
85610   Dali::ImageDimensions arg2 ;
85611   Dali::ImageDimensions *argp2 ;
85612   Dali::PixelData result;
85613
85614   if (!jarg1) {
85615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85616     return 0;
85617   }
85618   std::string arg1_str(jarg1);
85619   arg1 = &arg1_str;
85620   argp2 = (Dali::ImageDimensions *)jarg2;
85621   if (!argp2) {
85622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85623     return 0;
85624   }
85625   arg2 = *argp2;
85626   {
85627     try {
85628       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
85629     } catch (std::out_of_range& e) {
85630       {
85631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85632       };
85633     } catch (std::exception& e) {
85634       {
85635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85636       };
85637     } catch (...) {
85638       {
85639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85640       };
85641     }
85642   }
85643   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85644
85645   //argout typemap for const std::string&
85646
85647   return jresult;
85648 }
85649
85650
85651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
85652   void * jresult ;
85653   std::string *arg1 = 0 ;
85654   Dali::ImageDimensions arg2 ;
85655   Dali::FittingMode::Type arg3 ;
85656   Dali::SamplingMode::Type arg4 ;
85657   bool arg5 ;
85658   Dali::ImageDimensions *argp2 ;
85659   Dali::PixelData result;
85660
85661   if (!jarg1) {
85662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85663     return 0;
85664   }
85665   std::string arg1_str(jarg1);
85666   arg1 = &arg1_str;
85667   argp2 = (Dali::ImageDimensions *)jarg2;
85668   if (!argp2) {
85669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85670     return 0;
85671   }
85672   arg2 = *argp2;
85673   arg3 = (Dali::FittingMode::Type)jarg3;
85674   arg4 = (Dali::SamplingMode::Type)jarg4;
85675   arg5 = jarg5 ? true : false;
85676   {
85677     try {
85678       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
85679     } catch (std::out_of_range& e) {
85680       {
85681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85682       };
85683     } catch (std::exception& e) {
85684       {
85685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85686       };
85687     } catch (...) {
85688       {
85689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85690       };
85691     }
85692   }
85693   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85694
85695   //argout typemap for const std::string&
85696
85697   return jresult;
85698 }
85699
85700
85701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
85702   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
85703
85704   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
85705   {
85706     try {
85707       delete arg1;
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 void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
85726   void * jresult ;
85727   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
85728   Dali::Actor arg2 ;
85729   Dali::Actor arg3 ;
85730   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
85731   Dali::Actor *argp2 ;
85732   Dali::Actor *argp3 ;
85733   Dali::Actor result;
85734
85735   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
85736   argp2 = (Dali::Actor *)jarg2;
85737   if (!argp2) {
85738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85739     return 0;
85740   }
85741   arg2 = *argp2;
85742   argp3 = (Dali::Actor *)jarg3;
85743   if (!argp3) {
85744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85745     return 0;
85746   }
85747   arg3 = *argp3;
85748   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
85749   {
85750     try {
85751       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
85752     } catch (std::out_of_range& e) {
85753       {
85754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85755       };
85756     } catch (std::exception& e) {
85757       {
85758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85759       };
85760     } catch (...) {
85761       {
85762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85763       };
85764     }
85765   }
85766   jresult = new Dali::Actor((const Dali::Actor &)result);
85767   return jresult;
85768 }
85769
85770
85771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
85772   void * jresult ;
85773   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
85774
85775   {
85776     try {
85777       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
85778     } catch (std::out_of_range& e) {
85779       {
85780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85781       };
85782     } catch (std::exception& e) {
85783       {
85784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85785       };
85786     } catch (...) {
85787       {
85788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85789       };
85790     }
85791   }
85792   jresult = (void *)result;
85793   return jresult;
85794 }
85795
85796
85797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
85798   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
85799   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
85800   if (director) {
85801     director->swig_connect_director(callback0);
85802   }
85803 }
85804
85805
85806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
85807   KeyboardFocusManager arg1 ;
85808   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
85809   KeyboardFocusManager *argp1 ;
85810
85811   argp1 = (KeyboardFocusManager *)jarg1;
85812   if (!argp1) {
85813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
85814     return ;
85815   }
85816   arg1 = *argp1;
85817   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
85818   if (!arg2) {
85819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
85820     return ;
85821   }
85822   {
85823     try {
85824       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
85825     } catch (std::out_of_range& e) {
85826       {
85827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85828       };
85829     } catch (std::exception& e) {
85830       {
85831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85832       };
85833     } catch (...) {
85834       {
85835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85836       };
85837     }
85838   }
85839 }
85840
85841
85842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
85843   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85844
85845   arg1 = (std::vector< unsigned int > *)jarg1;
85846   {
85847     try {
85848       (arg1)->clear();
85849     } catch (std::out_of_range& e) {
85850       {
85851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85852       };
85853     } catch (std::exception& e) {
85854       {
85855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85856       };
85857     } catch (...) {
85858       {
85859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85860       };
85861     }
85862   }
85863 }
85864
85865
85866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
85867   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85868   unsigned int *arg2 = 0 ;
85869   unsigned int temp2 ;
85870
85871   arg1 = (std::vector< unsigned int > *)jarg1;
85872   temp2 = (unsigned int)jarg2;
85873   arg2 = &temp2;
85874   {
85875     try {
85876       (arg1)->push_back((unsigned int const &)*arg2);
85877     } catch (std::out_of_range& e) {
85878       {
85879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85880       };
85881     } catch (std::exception& e) {
85882       {
85883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85884       };
85885     } catch (...) {
85886       {
85887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85888       };
85889     }
85890   }
85891 }
85892
85893
85894 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
85895   unsigned long jresult ;
85896   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85897   std::vector< unsigned int >::size_type result;
85898
85899   arg1 = (std::vector< unsigned int > *)jarg1;
85900   {
85901     try {
85902       result = ((std::vector< unsigned int > const *)arg1)->size();
85903     } catch (std::out_of_range& e) {
85904       {
85905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85906       };
85907     } catch (std::exception& e) {
85908       {
85909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85910       };
85911     } catch (...) {
85912       {
85913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85914       };
85915     }
85916   }
85917   jresult = (unsigned long)result;
85918   return jresult;
85919 }
85920
85921
85922 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
85923   unsigned long jresult ;
85924   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85925   std::vector< unsigned int >::size_type result;
85926
85927   arg1 = (std::vector< unsigned int > *)jarg1;
85928   {
85929     try {
85930       result = ((std::vector< unsigned int > const *)arg1)->capacity();
85931     } catch (std::out_of_range& e) {
85932       {
85933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85934       };
85935     } catch (std::exception& e) {
85936       {
85937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85938       };
85939     } catch (...) {
85940       {
85941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85942       };
85943     }
85944   }
85945   jresult = (unsigned long)result;
85946   return jresult;
85947 }
85948
85949
85950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
85951   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85952   std::vector< unsigned int >::size_type arg2 ;
85953
85954   arg1 = (std::vector< unsigned int > *)jarg1;
85955   arg2 = (std::vector< unsigned int >::size_type)jarg2;
85956   {
85957     try {
85958       (arg1)->reserve(arg2);
85959     } catch (std::out_of_range& e) {
85960       {
85961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85962       };
85963     } catch (std::exception& e) {
85964       {
85965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85966       };
85967     } catch (...) {
85968       {
85969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85970       };
85971     }
85972   }
85973 }
85974
85975
85976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
85977   void * jresult ;
85978   std::vector< unsigned int > *result = 0 ;
85979
85980   {
85981     try {
85982       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
85983     } catch (std::out_of_range& e) {
85984       {
85985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85986       };
85987     } catch (std::exception& e) {
85988       {
85989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85990       };
85991     } catch (...) {
85992       {
85993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85994       };
85995     }
85996   }
85997   jresult = (void *)result;
85998   return jresult;
85999 }
86000
86001
86002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
86003   void * jresult ;
86004   std::vector< unsigned int > *arg1 = 0 ;
86005   std::vector< unsigned int > *result = 0 ;
86006
86007   arg1 = (std::vector< unsigned int > *)jarg1;
86008   if (!arg1) {
86009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86010     return 0;
86011   }
86012   {
86013     try {
86014       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
86015     } catch (std::out_of_range& e) {
86016       {
86017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86018       };
86019     } catch (std::exception& e) {
86020       {
86021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86022       };
86023     } catch (...) {
86024       {
86025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86026       };
86027     }
86028   }
86029   jresult = (void *)result;
86030   return jresult;
86031 }
86032
86033
86034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
86035   void * jresult ;
86036   int arg1 ;
86037   std::vector< unsigned int > *result = 0 ;
86038
86039   arg1 = (int)jarg1;
86040   {
86041     try {
86042       try {
86043         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
86044       }
86045       catch(std::out_of_range &_e) {
86046         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86047         return 0;
86048       }
86049
86050     } catch (std::out_of_range& e) {
86051       {
86052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86053       };
86054     } catch (std::exception& e) {
86055       {
86056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86057       };
86058     } catch (...) {
86059       {
86060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86061       };
86062     }
86063   }
86064   jresult = (void *)result;
86065   return jresult;
86066 }
86067
86068
86069 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
86070   unsigned int jresult ;
86071   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86072   int arg2 ;
86073   unsigned int result;
86074
86075   arg1 = (std::vector< unsigned int > *)jarg1;
86076   arg2 = (int)jarg2;
86077   {
86078     try {
86079       try {
86080         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
86081       }
86082       catch(std::out_of_range &_e) {
86083         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86084         return 0;
86085       }
86086
86087     } catch (std::out_of_range& e) {
86088       {
86089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86090       };
86091     } catch (std::exception& e) {
86092       {
86093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86094       };
86095     } catch (...) {
86096       {
86097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86098       };
86099     }
86100   }
86101   jresult = result;
86102   return jresult;
86103 }
86104
86105
86106 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
86107   unsigned int jresult ;
86108   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86109   int arg2 ;
86110   unsigned int *result = 0 ;
86111
86112   arg1 = (std::vector< unsigned int > *)jarg1;
86113   arg2 = (int)jarg2;
86114   {
86115     try {
86116       try {
86117         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
86118       }
86119       catch(std::out_of_range &_e) {
86120         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86121         return 0;
86122       }
86123
86124     } catch (std::out_of_range& e) {
86125       {
86126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86127       };
86128     } catch (std::exception& e) {
86129       {
86130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86131       };
86132     } catch (...) {
86133       {
86134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86135       };
86136     }
86137   }
86138   jresult = *result;
86139   return jresult;
86140 }
86141
86142
86143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
86144   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86145   int arg2 ;
86146   unsigned int *arg3 = 0 ;
86147   unsigned int temp3 ;
86148
86149   arg1 = (std::vector< unsigned int > *)jarg1;
86150   arg2 = (int)jarg2;
86151   temp3 = (unsigned int)jarg3;
86152   arg3 = &temp3;
86153   {
86154     try {
86155       try {
86156         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
86157       }
86158       catch(std::out_of_range &_e) {
86159         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86160         return ;
86161       }
86162
86163     } catch (std::out_of_range& e) {
86164       {
86165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86166       };
86167     } catch (std::exception& e) {
86168       {
86169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86170       };
86171     } catch (...) {
86172       {
86173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86174       };
86175     }
86176   }
86177 }
86178
86179
86180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
86181   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86182   std::vector< unsigned int > *arg2 = 0 ;
86183
86184   arg1 = (std::vector< unsigned int > *)jarg1;
86185   arg2 = (std::vector< unsigned int > *)jarg2;
86186   if (!arg2) {
86187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86188     return ;
86189   }
86190   {
86191     try {
86192       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
86193     } catch (std::out_of_range& e) {
86194       {
86195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86196       };
86197     } catch (std::exception& e) {
86198       {
86199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86200       };
86201     } catch (...) {
86202       {
86203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86204       };
86205     }
86206   }
86207 }
86208
86209
86210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
86211   void * jresult ;
86212   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86213   int arg2 ;
86214   int arg3 ;
86215   std::vector< unsigned int > *result = 0 ;
86216
86217   arg1 = (std::vector< unsigned int > *)jarg1;
86218   arg2 = (int)jarg2;
86219   arg3 = (int)jarg3;
86220   {
86221     try {
86222       try {
86223         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
86224       }
86225       catch(std::out_of_range &_e) {
86226         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86227         return 0;
86228       }
86229       catch(std::invalid_argument &_e) {
86230         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86231         return 0;
86232       }
86233
86234     } catch (std::out_of_range& e) {
86235       {
86236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86237       };
86238     } catch (std::exception& e) {
86239       {
86240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86241       };
86242     } catch (...) {
86243       {
86244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86245       };
86246     }
86247   }
86248   jresult = (void *)result;
86249   return jresult;
86250 }
86251
86252
86253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
86254   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86255   int arg2 ;
86256   unsigned int *arg3 = 0 ;
86257   unsigned int temp3 ;
86258
86259   arg1 = (std::vector< unsigned int > *)jarg1;
86260   arg2 = (int)jarg2;
86261   temp3 = (unsigned int)jarg3;
86262   arg3 = &temp3;
86263   {
86264     try {
86265       try {
86266         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
86267       }
86268       catch(std::out_of_range &_e) {
86269         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86270         return ;
86271       }
86272
86273     } catch (std::out_of_range& e) {
86274       {
86275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86276       };
86277     } catch (std::exception& e) {
86278       {
86279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86280       };
86281     } catch (...) {
86282       {
86283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86284       };
86285     }
86286   }
86287 }
86288
86289
86290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
86291   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86292   int arg2 ;
86293   std::vector< unsigned int > *arg3 = 0 ;
86294
86295   arg1 = (std::vector< unsigned int > *)jarg1;
86296   arg2 = (int)jarg2;
86297   arg3 = (std::vector< unsigned int > *)jarg3;
86298   if (!arg3) {
86299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86300     return ;
86301   }
86302   {
86303     try {
86304       try {
86305         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
86306       }
86307       catch(std::out_of_range &_e) {
86308         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86309         return ;
86310       }
86311
86312     } catch (std::out_of_range& e) {
86313       {
86314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86315       };
86316     } catch (std::exception& e) {
86317       {
86318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86319       };
86320     } catch (...) {
86321       {
86322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86323       };
86324     }
86325   }
86326 }
86327
86328
86329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
86330   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86331   int arg2 ;
86332
86333   arg1 = (std::vector< unsigned int > *)jarg1;
86334   arg2 = (int)jarg2;
86335   {
86336     try {
86337       try {
86338         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
86339       }
86340       catch(std::out_of_range &_e) {
86341         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86342         return ;
86343       }
86344
86345     } catch (std::out_of_range& e) {
86346       {
86347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86348       };
86349     } catch (std::exception& e) {
86350       {
86351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86352       };
86353     } catch (...) {
86354       {
86355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86356       };
86357     }
86358   }
86359 }
86360
86361
86362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
86363   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86364   int arg2 ;
86365   int arg3 ;
86366
86367   arg1 = (std::vector< unsigned int > *)jarg1;
86368   arg2 = (int)jarg2;
86369   arg3 = (int)jarg3;
86370   {
86371     try {
86372       try {
86373         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
86374       }
86375       catch(std::out_of_range &_e) {
86376         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86377         return ;
86378       }
86379       catch(std::invalid_argument &_e) {
86380         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86381         return ;
86382       }
86383
86384     } catch (std::out_of_range& e) {
86385       {
86386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86387       };
86388     } catch (std::exception& e) {
86389       {
86390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86391       };
86392     } catch (...) {
86393       {
86394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86395       };
86396     }
86397   }
86398 }
86399
86400
86401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
86402   void * jresult ;
86403   unsigned int *arg1 = 0 ;
86404   int arg2 ;
86405   unsigned int temp1 ;
86406   std::vector< unsigned int > *result = 0 ;
86407
86408   temp1 = (unsigned int)jarg1;
86409   arg1 = &temp1;
86410   arg2 = (int)jarg2;
86411   {
86412     try {
86413       try {
86414         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
86415       }
86416       catch(std::out_of_range &_e) {
86417         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86418         return 0;
86419       }
86420
86421     } catch (std::out_of_range& e) {
86422       {
86423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86424       };
86425     } catch (std::exception& e) {
86426       {
86427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86428       };
86429     } catch (...) {
86430       {
86431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86432       };
86433     }
86434   }
86435   jresult = (void *)result;
86436   return jresult;
86437 }
86438
86439
86440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
86441   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86442
86443   arg1 = (std::vector< unsigned int > *)jarg1;
86444   {
86445     try {
86446       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
86447     } catch (std::out_of_range& e) {
86448       {
86449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86450       };
86451     } catch (std::exception& e) {
86452       {
86453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86454       };
86455     } catch (...) {
86456       {
86457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86458       };
86459     }
86460   }
86461 }
86462
86463
86464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
86465   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86466   int arg2 ;
86467   int arg3 ;
86468
86469   arg1 = (std::vector< unsigned int > *)jarg1;
86470   arg2 = (int)jarg2;
86471   arg3 = (int)jarg3;
86472   {
86473     try {
86474       try {
86475         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
86476       }
86477       catch(std::out_of_range &_e) {
86478         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86479         return ;
86480       }
86481       catch(std::invalid_argument &_e) {
86482         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86483         return ;
86484       }
86485
86486     } catch (std::out_of_range& e) {
86487       {
86488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86489       };
86490     } catch (std::exception& e) {
86491       {
86492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86493       };
86494     } catch (...) {
86495       {
86496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86497       };
86498     }
86499   }
86500 }
86501
86502
86503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
86504   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86505   int arg2 ;
86506   std::vector< unsigned int > *arg3 = 0 ;
86507
86508   arg1 = (std::vector< unsigned int > *)jarg1;
86509   arg2 = (int)jarg2;
86510   arg3 = (std::vector< unsigned int > *)jarg3;
86511   if (!arg3) {
86512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86513     return ;
86514   }
86515   {
86516     try {
86517       try {
86518         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
86519       }
86520       catch(std::out_of_range &_e) {
86521         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86522         return ;
86523       }
86524
86525     } catch (std::out_of_range& e) {
86526       {
86527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86528       };
86529     } catch (std::exception& e) {
86530       {
86531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86532       };
86533     } catch (...) {
86534       {
86535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86536       };
86537     }
86538   }
86539 }
86540
86541
86542 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
86543   unsigned int jresult ;
86544   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86545   unsigned int *arg2 = 0 ;
86546   unsigned int temp2 ;
86547   bool result;
86548
86549   arg1 = (std::vector< unsigned int > *)jarg1;
86550   temp2 = (unsigned int)jarg2;
86551   arg2 = &temp2;
86552   {
86553     try {
86554       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
86555     } catch (std::out_of_range& e) {
86556       {
86557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86558       };
86559     } catch (std::exception& e) {
86560       {
86561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86562       };
86563     } catch (...) {
86564       {
86565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86566       };
86567     }
86568   }
86569   jresult = result;
86570   return jresult;
86571 }
86572
86573
86574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
86575   int jresult ;
86576   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86577   unsigned int *arg2 = 0 ;
86578   unsigned int temp2 ;
86579   int result;
86580
86581   arg1 = (std::vector< unsigned int > *)jarg1;
86582   temp2 = (unsigned int)jarg2;
86583   arg2 = &temp2;
86584   {
86585     try {
86586       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
86587     } catch (std::out_of_range& e) {
86588       {
86589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86590       };
86591     } catch (std::exception& e) {
86592       {
86593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86594       };
86595     } catch (...) {
86596       {
86597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86598       };
86599     }
86600   }
86601   jresult = result;
86602   return jresult;
86603 }
86604
86605
86606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
86607   int jresult ;
86608   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86609   unsigned int *arg2 = 0 ;
86610   unsigned int temp2 ;
86611   int result;
86612
86613   arg1 = (std::vector< unsigned int > *)jarg1;
86614   temp2 = (unsigned int)jarg2;
86615   arg2 = &temp2;
86616   {
86617     try {
86618       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
86619     } catch (std::out_of_range& e) {
86620       {
86621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86622       };
86623     } catch (std::exception& e) {
86624       {
86625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86626       };
86627     } catch (...) {
86628       {
86629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86630       };
86631     }
86632   }
86633   jresult = result;
86634   return jresult;
86635 }
86636
86637
86638 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
86639   unsigned int jresult ;
86640   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86641   unsigned int *arg2 = 0 ;
86642   unsigned int temp2 ;
86643   bool result;
86644
86645   arg1 = (std::vector< unsigned int > *)jarg1;
86646   temp2 = (unsigned int)jarg2;
86647   arg2 = &temp2;
86648   {
86649     try {
86650       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
86651     } catch (std::out_of_range& e) {
86652       {
86653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86654       };
86655     } catch (std::exception& e) {
86656       {
86657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86658       };
86659     } catch (...) {
86660       {
86661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86662       };
86663     }
86664   }
86665   jresult = result;
86666   return jresult;
86667 }
86668
86669
86670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
86671   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86672
86673   arg1 = (std::vector< unsigned int > *)jarg1;
86674   {
86675     try {
86676       delete arg1;
86677     } catch (std::out_of_range& e) {
86678       {
86679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86680       };
86681     } catch (std::exception& e) {
86682       {
86683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86684       };
86685     } catch (...) {
86686       {
86687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86688       };
86689     }
86690   }
86691 }
86692
86693
86694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
86695   void * jresult ;
86696   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86697
86698   {
86699     try {
86700       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
86701     } catch (std::out_of_range& e) {
86702       {
86703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86704       };
86705     } catch (std::exception& e) {
86706       {
86707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86708       };
86709     } catch (...) {
86710       {
86711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86712       };
86713     }
86714   }
86715   jresult = (void *)result;
86716   return jresult;
86717 }
86718
86719
86720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
86721   void * jresult ;
86722   unsigned int arg1 ;
86723   Dali::Actor arg2 ;
86724   Dali::Actor *argp2 ;
86725   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86726
86727   arg1 = (unsigned int)jarg1;
86728   argp2 = (Dali::Actor *)jarg2;
86729   if (!argp2) {
86730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86731     return 0;
86732   }
86733   arg2 = *argp2;
86734   {
86735     try {
86736       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
86737     } catch (std::out_of_range& e) {
86738       {
86739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86740       };
86741     } catch (std::exception& e) {
86742       {
86743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86744       };
86745     } catch (...) {
86746       {
86747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86748       };
86749     }
86750   }
86751   jresult = (void *)result;
86752   return jresult;
86753 }
86754
86755
86756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
86757   void * jresult ;
86758   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
86759   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86760
86761   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86762   if (!arg1) {
86763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
86764     return 0;
86765   }
86766   {
86767     try {
86768       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
86769     } catch (std::out_of_range& e) {
86770       {
86771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86772       };
86773     } catch (std::exception& e) {
86774       {
86775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86776       };
86777     } catch (...) {
86778       {
86779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86780       };
86781     }
86782   }
86783   jresult = (void *)result;
86784   return jresult;
86785 }
86786
86787
86788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
86789   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86790   unsigned int arg2 ;
86791
86792   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86793   arg2 = (unsigned int)jarg2;
86794   if (arg1) (arg1)->first = arg2;
86795 }
86796
86797
86798 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
86799   unsigned int jresult ;
86800   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86801   unsigned int result;
86802
86803   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86804   result = (unsigned int) ((arg1)->first);
86805   jresult = result;
86806   return jresult;
86807 }
86808
86809
86810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
86811   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86812   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
86813
86814   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86815   arg2 = (Dali::Actor *)jarg2;
86816   if (arg1) (arg1)->second = *arg2;
86817 }
86818
86819
86820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
86821   void * jresult ;
86822   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86823   Dali::Actor *result = 0 ;
86824
86825   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86826   result = (Dali::Actor *)& ((arg1)->second);
86827   jresult = (void *)result;
86828   return jresult;
86829 }
86830
86831
86832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
86833   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86834
86835   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86836   {
86837     try {
86838       delete arg1;
86839     } catch (std::out_of_range& e) {
86840       {
86841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86842       };
86843     } catch (std::exception& e) {
86844       {
86845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86846       };
86847     } catch (...) {
86848       {
86849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86850       };
86851     }
86852   }
86853 }
86854
86855
86856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
86857   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86858
86859   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86860   {
86861     try {
86862       (arg1)->clear();
86863     } catch (std::out_of_range& e) {
86864       {
86865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86866       };
86867     } catch (std::exception& e) {
86868       {
86869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86870       };
86871     } catch (...) {
86872       {
86873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86874       };
86875     }
86876   }
86877 }
86878
86879
86880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
86881   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86882   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
86883
86884   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86885   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
86886   if (!arg2) {
86887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
86888     return ;
86889   }
86890   {
86891     try {
86892       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
86893     } catch (std::out_of_range& e) {
86894       {
86895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86896       };
86897     } catch (std::exception& e) {
86898       {
86899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86900       };
86901     } catch (...) {
86902       {
86903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86904       };
86905     }
86906   }
86907 }
86908
86909
86910 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
86911   unsigned long jresult ;
86912   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86913   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
86914
86915   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86916   {
86917     try {
86918       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
86919     } catch (std::out_of_range& e) {
86920       {
86921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86922       };
86923     } catch (std::exception& e) {
86924       {
86925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86926       };
86927     } catch (...) {
86928       {
86929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86930       };
86931     }
86932   }
86933   jresult = (unsigned long)result;
86934   return jresult;
86935 }
86936
86937
86938 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
86939   unsigned long jresult ;
86940   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86941   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
86942
86943   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86944   {
86945     try {
86946       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
86947     } catch (std::out_of_range& e) {
86948       {
86949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86950       };
86951     } catch (std::exception& e) {
86952       {
86953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86954       };
86955     } catch (...) {
86956       {
86957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86958       };
86959     }
86960   }
86961   jresult = (unsigned long)result;
86962   return jresult;
86963 }
86964
86965
86966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
86967   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86968   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
86969
86970   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86971   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
86972   {
86973     try {
86974       (arg1)->reserve(arg2);
86975     } catch (std::out_of_range& e) {
86976       {
86977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86978       };
86979     } catch (std::exception& e) {
86980       {
86981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86982       };
86983     } catch (...) {
86984       {
86985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86986       };
86987     }
86988   }
86989 }
86990
86991
86992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
86993   void * jresult ;
86994   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
86995
86996   {
86997     try {
86998       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
86999     } catch (std::out_of_range& e) {
87000       {
87001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87002       };
87003     } catch (std::exception& e) {
87004       {
87005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87006       };
87007     } catch (...) {
87008       {
87009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87010       };
87011     }
87012   }
87013   jresult = (void *)result;
87014   return jresult;
87015 }
87016
87017
87018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
87019   void * jresult ;
87020   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
87021   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87022
87023   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87024   if (!arg1) {
87025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87026     return 0;
87027   }
87028   {
87029     try {
87030       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);
87031     } catch (std::out_of_range& e) {
87032       {
87033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87034       };
87035     } catch (std::exception& e) {
87036       {
87037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87038       };
87039     } catch (...) {
87040       {
87041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87042       };
87043     }
87044   }
87045   jresult = (void *)result;
87046   return jresult;
87047 }
87048
87049
87050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
87051   void * jresult ;
87052   int arg1 ;
87053   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87054
87055   arg1 = (int)jarg1;
87056   {
87057     try {
87058       try {
87059         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);
87060       }
87061       catch(std::out_of_range &_e) {
87062         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87063         return 0;
87064       }
87065
87066     } catch (std::out_of_range& e) {
87067       {
87068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87069       };
87070     } catch (std::exception& e) {
87071       {
87072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87073       };
87074     } catch (...) {
87075       {
87076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87077       };
87078     }
87079   }
87080   jresult = (void *)result;
87081   return jresult;
87082 }
87083
87084
87085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
87086   void * jresult ;
87087   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87088   int arg2 ;
87089   std::pair< unsigned int,Dali::Actor > result;
87090
87091   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87092   arg2 = (int)jarg2;
87093   {
87094     try {
87095       try {
87096         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
87097       }
87098       catch(std::out_of_range &_e) {
87099         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87100         return 0;
87101       }
87102
87103     } catch (std::out_of_range& e) {
87104       {
87105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87106       };
87107     } catch (std::exception& e) {
87108       {
87109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87110       };
87111     } catch (...) {
87112       {
87113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87114       };
87115     }
87116   }
87117   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
87118   return jresult;
87119 }
87120
87121
87122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
87123   void * jresult ;
87124   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87125   int arg2 ;
87126   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87127
87128   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87129   arg2 = (int)jarg2;
87130   {
87131     try {
87132       try {
87133         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
87134       }
87135       catch(std::out_of_range &_e) {
87136         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87137         return 0;
87138       }
87139
87140     } catch (std::out_of_range& e) {
87141       {
87142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87143       };
87144     } catch (std::exception& e) {
87145       {
87146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87147       };
87148     } catch (...) {
87149       {
87150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87151       };
87152     }
87153   }
87154   jresult = (void *)result;
87155   return jresult;
87156 }
87157
87158
87159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
87160   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87161   int arg2 ;
87162   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
87163
87164   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87165   arg2 = (int)jarg2;
87166   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
87167   if (!arg3) {
87168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87169     return ;
87170   }
87171   {
87172     try {
87173       try {
87174         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);
87175       }
87176       catch(std::out_of_range &_e) {
87177         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87178         return ;
87179       }
87180
87181     } catch (std::out_of_range& e) {
87182       {
87183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87184       };
87185     } catch (std::exception& e) {
87186       {
87187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87188       };
87189     } catch (...) {
87190       {
87191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87192       };
87193     }
87194   }
87195 }
87196
87197
87198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
87199   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87200   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
87201
87202   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87203   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
87204   if (!arg2) {
87205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87206     return ;
87207   }
87208   {
87209     try {
87210       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);
87211     } catch (std::out_of_range& e) {
87212       {
87213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87214       };
87215     } catch (std::exception& e) {
87216       {
87217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87218       };
87219     } catch (...) {
87220       {
87221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87222       };
87223     }
87224   }
87225 }
87226
87227
87228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87229   void * jresult ;
87230   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87231   int arg2 ;
87232   int arg3 ;
87233   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87234
87235   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87236   arg2 = (int)jarg2;
87237   arg3 = (int)jarg3;
87238   {
87239     try {
87240       try {
87241         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);
87242       }
87243       catch(std::out_of_range &_e) {
87244         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87245         return 0;
87246       }
87247       catch(std::invalid_argument &_e) {
87248         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87249         return 0;
87250       }
87251
87252     } catch (std::out_of_range& e) {
87253       {
87254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87255       };
87256     } catch (std::exception& e) {
87257       {
87258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87259       };
87260     } catch (...) {
87261       {
87262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87263       };
87264     }
87265   }
87266   jresult = (void *)result;
87267   return jresult;
87268 }
87269
87270
87271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
87272   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87273   int arg2 ;
87274   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
87275
87276   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87277   arg2 = (int)jarg2;
87278   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
87279   if (!arg3) {
87280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87281     return ;
87282   }
87283   {
87284     try {
87285       try {
87286         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);
87287       }
87288       catch(std::out_of_range &_e) {
87289         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87290         return ;
87291       }
87292
87293     } catch (std::out_of_range& e) {
87294       {
87295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87296       };
87297     } catch (std::exception& e) {
87298       {
87299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87300       };
87301     } catch (...) {
87302       {
87303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87304       };
87305     }
87306   }
87307 }
87308
87309
87310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87311   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87312   int arg2 ;
87313   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
87314
87315   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87316   arg2 = (int)jarg2;
87317   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
87318   if (!arg3) {
87319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87320     return ;
87321   }
87322   {
87323     try {
87324       try {
87325         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);
87326       }
87327       catch(std::out_of_range &_e) {
87328         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87329         return ;
87330       }
87331
87332     } catch (std::out_of_range& e) {
87333       {
87334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87335       };
87336     } catch (std::exception& e) {
87337       {
87338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87339       };
87340     } catch (...) {
87341       {
87342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87343       };
87344     }
87345   }
87346 }
87347
87348
87349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
87350   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87351   int arg2 ;
87352
87353   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87354   arg2 = (int)jarg2;
87355   {
87356     try {
87357       try {
87358         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
87359       }
87360       catch(std::out_of_range &_e) {
87361         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87362         return ;
87363       }
87364
87365     } catch (std::out_of_range& e) {
87366       {
87367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87368       };
87369     } catch (std::exception& e) {
87370       {
87371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87372       };
87373     } catch (...) {
87374       {
87375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87376       };
87377     }
87378   }
87379 }
87380
87381
87382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
87383   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87384   int arg2 ;
87385   int arg3 ;
87386
87387   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87388   arg2 = (int)jarg2;
87389   arg3 = (int)jarg3;
87390   {
87391     try {
87392       try {
87393         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
87394       }
87395       catch(std::out_of_range &_e) {
87396         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87397         return ;
87398       }
87399       catch(std::invalid_argument &_e) {
87400         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87401         return ;
87402       }
87403
87404     } catch (std::out_of_range& e) {
87405       {
87406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87407       };
87408     } catch (std::exception& e) {
87409       {
87410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87411       };
87412     } catch (...) {
87413       {
87414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87415       };
87416     }
87417   }
87418 }
87419
87420
87421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
87422   void * jresult ;
87423   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
87424   int arg2 ;
87425   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87426
87427   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87428   if (!arg1) {
87429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87430     return 0;
87431   }
87432   arg2 = (int)jarg2;
87433   {
87434     try {
87435       try {
87436         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);
87437       }
87438       catch(std::out_of_range &_e) {
87439         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87440         return 0;
87441       }
87442
87443     } catch (std::out_of_range& e) {
87444       {
87445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87446       };
87447     } catch (std::exception& e) {
87448       {
87449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87450       };
87451     } catch (...) {
87452       {
87453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87454       };
87455     }
87456   }
87457   jresult = (void *)result;
87458   return jresult;
87459 }
87460
87461
87462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
87463   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87464
87465   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87466   {
87467     try {
87468       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
87469     } catch (std::out_of_range& e) {
87470       {
87471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87472       };
87473     } catch (std::exception& e) {
87474       {
87475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87476       };
87477     } catch (...) {
87478       {
87479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87480       };
87481     }
87482   }
87483 }
87484
87485
87486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
87487   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87488   int arg2 ;
87489   int arg3 ;
87490
87491   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87492   arg2 = (int)jarg2;
87493   arg3 = (int)jarg3;
87494   {
87495     try {
87496       try {
87497         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
87498       }
87499       catch(std::out_of_range &_e) {
87500         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87501         return ;
87502       }
87503       catch(std::invalid_argument &_e) {
87504         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87505         return ;
87506       }
87507
87508     } catch (std::out_of_range& e) {
87509       {
87510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87511       };
87512     } catch (std::exception& e) {
87513       {
87514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87515       };
87516     } catch (...) {
87517       {
87518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87519       };
87520     }
87521   }
87522 }
87523
87524
87525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
87526   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87527   int arg2 ;
87528   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
87529
87530   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87531   arg2 = (int)jarg2;
87532   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
87533   if (!arg3) {
87534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87535     return ;
87536   }
87537   {
87538     try {
87539       try {
87540         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);
87541       }
87542       catch(std::out_of_range &_e) {
87543         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87544         return ;
87545       }
87546
87547     } catch (std::out_of_range& e) {
87548       {
87549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87550       };
87551     } catch (std::exception& e) {
87552       {
87553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87554       };
87555     } catch (...) {
87556       {
87557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87558       };
87559     }
87560   }
87561 }
87562
87563
87564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
87565   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87566
87567   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87568   {
87569     try {
87570       delete arg1;
87571     } catch (std::out_of_range& e) {
87572       {
87573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87574       };
87575     } catch (std::exception& e) {
87576       {
87577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87578       };
87579     } catch (...) {
87580       {
87581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87582       };
87583     }
87584   }
87585 }
87586
87587
87588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
87589   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87590
87591   arg1 = (std::vector< Dali::Actor > *)jarg1;
87592   {
87593     try {
87594       (arg1)->clear();
87595     } catch (std::out_of_range& e) {
87596       {
87597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87598       };
87599     } catch (std::exception& e) {
87600       {
87601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87602       };
87603     } catch (...) {
87604       {
87605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87606       };
87607     }
87608   }
87609 }
87610
87611
87612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
87613   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87614   Dali::Actor *arg2 = 0 ;
87615
87616   arg1 = (std::vector< Dali::Actor > *)jarg1;
87617   arg2 = (Dali::Actor *)jarg2;
87618   if (!arg2) {
87619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
87620     return ;
87621   }
87622   {
87623     try {
87624       (arg1)->push_back((Dali::Actor const &)*arg2);
87625     } catch (std::out_of_range& e) {
87626       {
87627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87628       };
87629     } catch (std::exception& e) {
87630       {
87631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87632       };
87633     } catch (...) {
87634       {
87635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87636       };
87637     }
87638   }
87639 }
87640
87641
87642 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
87643   unsigned long jresult ;
87644   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87645   std::vector< Dali::Actor >::size_type result;
87646
87647   arg1 = (std::vector< Dali::Actor > *)jarg1;
87648   {
87649     try {
87650       result = ((std::vector< Dali::Actor > const *)arg1)->size();
87651     } catch (std::out_of_range& e) {
87652       {
87653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87654       };
87655     } catch (std::exception& e) {
87656       {
87657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87658       };
87659     } catch (...) {
87660       {
87661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87662       };
87663     }
87664   }
87665   jresult = (unsigned long)result;
87666   return jresult;
87667 }
87668
87669
87670 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
87671   unsigned long jresult ;
87672   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87673   std::vector< Dali::Actor >::size_type result;
87674
87675   arg1 = (std::vector< Dali::Actor > *)jarg1;
87676   {
87677     try {
87678       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
87679     } catch (std::out_of_range& e) {
87680       {
87681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87682       };
87683     } catch (std::exception& e) {
87684       {
87685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87686       };
87687     } catch (...) {
87688       {
87689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87690       };
87691     }
87692   }
87693   jresult = (unsigned long)result;
87694   return jresult;
87695 }
87696
87697
87698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
87699   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87700   std::vector< Dali::Actor >::size_type arg2 ;
87701
87702   arg1 = (std::vector< Dali::Actor > *)jarg1;
87703   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
87704   {
87705     try {
87706       (arg1)->reserve(arg2);
87707     } catch (std::out_of_range& e) {
87708       {
87709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87710       };
87711     } catch (std::exception& e) {
87712       {
87713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87714       };
87715     } catch (...) {
87716       {
87717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87718       };
87719     }
87720   }
87721 }
87722
87723
87724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
87725   void * jresult ;
87726   std::vector< Dali::Actor > *result = 0 ;
87727
87728   {
87729     try {
87730       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
87731     } catch (std::out_of_range& e) {
87732       {
87733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87734       };
87735     } catch (std::exception& e) {
87736       {
87737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87738       };
87739     } catch (...) {
87740       {
87741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87742       };
87743     }
87744   }
87745   jresult = (void *)result;
87746   return jresult;
87747 }
87748
87749
87750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
87751   void * jresult ;
87752   std::vector< Dali::Actor > *arg1 = 0 ;
87753   std::vector< Dali::Actor > *result = 0 ;
87754
87755   arg1 = (std::vector< Dali::Actor > *)jarg1;
87756   if (!arg1) {
87757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
87758     return 0;
87759   }
87760   {
87761     try {
87762       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
87763     } catch (std::out_of_range& e) {
87764       {
87765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87766       };
87767     } catch (std::exception& e) {
87768       {
87769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87770       };
87771     } catch (...) {
87772       {
87773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87774       };
87775     }
87776   }
87777   jresult = (void *)result;
87778   return jresult;
87779 }
87780
87781
87782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
87783   void * jresult ;
87784   int arg1 ;
87785   std::vector< Dali::Actor > *result = 0 ;
87786
87787   arg1 = (int)jarg1;
87788   {
87789     try {
87790       try {
87791         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
87792       }
87793       catch(std::out_of_range &_e) {
87794         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87795         return 0;
87796       }
87797
87798     } catch (std::out_of_range& e) {
87799       {
87800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87801       };
87802     } catch (std::exception& e) {
87803       {
87804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87805       };
87806     } catch (...) {
87807       {
87808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87809       };
87810     }
87811   }
87812   jresult = (void *)result;
87813   return jresult;
87814 }
87815
87816
87817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
87818   void * jresult ;
87819   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87820   int arg2 ;
87821   Dali::Actor result;
87822
87823   arg1 = (std::vector< Dali::Actor > *)jarg1;
87824   arg2 = (int)jarg2;
87825   {
87826     try {
87827       try {
87828         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
87829       }
87830       catch(std::out_of_range &_e) {
87831         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87832         return 0;
87833       }
87834
87835     } catch (std::out_of_range& e) {
87836       {
87837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87838       };
87839     } catch (std::exception& e) {
87840       {
87841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87842       };
87843     } catch (...) {
87844       {
87845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87846       };
87847     }
87848   }
87849   jresult = new Dali::Actor((const Dali::Actor &)result);
87850   return jresult;
87851 }
87852
87853
87854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
87855   void * jresult ;
87856   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87857   int arg2 ;
87858   Dali::Actor *result = 0 ;
87859
87860   arg1 = (std::vector< Dali::Actor > *)jarg1;
87861   arg2 = (int)jarg2;
87862   {
87863     try {
87864       try {
87865         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
87866       }
87867       catch(std::out_of_range &_e) {
87868         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87869         return 0;
87870       }
87871
87872     } catch (std::out_of_range& e) {
87873       {
87874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87875       };
87876     } catch (std::exception& e) {
87877       {
87878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87879       };
87880     } catch (...) {
87881       {
87882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87883       };
87884     }
87885   }
87886   jresult = (void *)result;
87887   return jresult;
87888 }
87889
87890
87891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
87892   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87893   int arg2 ;
87894   Dali::Actor *arg3 = 0 ;
87895
87896   arg1 = (std::vector< Dali::Actor > *)jarg1;
87897   arg2 = (int)jarg2;
87898   arg3 = (Dali::Actor *)jarg3;
87899   if (!arg3) {
87900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
87901     return ;
87902   }
87903   {
87904     try {
87905       try {
87906         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
87907       }
87908       catch(std::out_of_range &_e) {
87909         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87910         return ;
87911       }
87912
87913     } catch (std::out_of_range& e) {
87914       {
87915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87916       };
87917     } catch (std::exception& e) {
87918       {
87919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87920       };
87921     } catch (...) {
87922       {
87923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87924       };
87925     }
87926   }
87927 }
87928
87929
87930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
87931   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87932   std::vector< Dali::Actor > *arg2 = 0 ;
87933
87934   arg1 = (std::vector< Dali::Actor > *)jarg1;
87935   arg2 = (std::vector< Dali::Actor > *)jarg2;
87936   if (!arg2) {
87937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
87938     return ;
87939   }
87940   {
87941     try {
87942       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
87943     } catch (std::out_of_range& e) {
87944       {
87945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87946       };
87947     } catch (std::exception& e) {
87948       {
87949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87950       };
87951     } catch (...) {
87952       {
87953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87954       };
87955     }
87956   }
87957 }
87958
87959
87960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87961   void * jresult ;
87962   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87963   int arg2 ;
87964   int arg3 ;
87965   std::vector< Dali::Actor > *result = 0 ;
87966
87967   arg1 = (std::vector< Dali::Actor > *)jarg1;
87968   arg2 = (int)jarg2;
87969   arg3 = (int)jarg3;
87970   {
87971     try {
87972       try {
87973         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
87974       }
87975       catch(std::out_of_range &_e) {
87976         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87977         return 0;
87978       }
87979       catch(std::invalid_argument &_e) {
87980         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87981         return 0;
87982       }
87983
87984     } catch (std::out_of_range& e) {
87985       {
87986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87987       };
87988     } catch (std::exception& e) {
87989       {
87990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87991       };
87992     } catch (...) {
87993       {
87994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87995       };
87996     }
87997   }
87998   jresult = (void *)result;
87999   return jresult;
88000 }
88001
88002
88003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
88004   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88005   int arg2 ;
88006   Dali::Actor *arg3 = 0 ;
88007
88008   arg1 = (std::vector< Dali::Actor > *)jarg1;
88009   arg2 = (int)jarg2;
88010   arg3 = (Dali::Actor *)jarg3;
88011   if (!arg3) {
88012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88013     return ;
88014   }
88015   {
88016     try {
88017       try {
88018         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
88019       }
88020       catch(std::out_of_range &_e) {
88021         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88022         return ;
88023       }
88024
88025     } catch (std::out_of_range& e) {
88026       {
88027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88028       };
88029     } catch (std::exception& e) {
88030       {
88031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88032       };
88033     } catch (...) {
88034       {
88035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88036       };
88037     }
88038   }
88039 }
88040
88041
88042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
88043   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88044   int arg2 ;
88045   std::vector< Dali::Actor > *arg3 = 0 ;
88046
88047   arg1 = (std::vector< Dali::Actor > *)jarg1;
88048   arg2 = (int)jarg2;
88049   arg3 = (std::vector< Dali::Actor > *)jarg3;
88050   if (!arg3) {
88051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
88052     return ;
88053   }
88054   {
88055     try {
88056       try {
88057         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
88058       }
88059       catch(std::out_of_range &_e) {
88060         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88061         return ;
88062       }
88063
88064     } catch (std::out_of_range& e) {
88065       {
88066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88067       };
88068     } catch (std::exception& e) {
88069       {
88070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88071       };
88072     } catch (...) {
88073       {
88074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88075       };
88076     }
88077   }
88078 }
88079
88080
88081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
88082   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88083   int arg2 ;
88084
88085   arg1 = (std::vector< Dali::Actor > *)jarg1;
88086   arg2 = (int)jarg2;
88087   {
88088     try {
88089       try {
88090         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
88091       }
88092       catch(std::out_of_range &_e) {
88093         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88094         return ;
88095       }
88096
88097     } catch (std::out_of_range& e) {
88098       {
88099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88100       };
88101     } catch (std::exception& e) {
88102       {
88103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88104       };
88105     } catch (...) {
88106       {
88107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88108       };
88109     }
88110   }
88111 }
88112
88113
88114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
88115   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88116   int arg2 ;
88117   int arg3 ;
88118
88119   arg1 = (std::vector< Dali::Actor > *)jarg1;
88120   arg2 = (int)jarg2;
88121   arg3 = (int)jarg3;
88122   {
88123     try {
88124       try {
88125         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
88126       }
88127       catch(std::out_of_range &_e) {
88128         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88129         return ;
88130       }
88131       catch(std::invalid_argument &_e) {
88132         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88133         return ;
88134       }
88135
88136     } catch (std::out_of_range& e) {
88137       {
88138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88139       };
88140     } catch (std::exception& e) {
88141       {
88142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88143       };
88144     } catch (...) {
88145       {
88146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88147       };
88148     }
88149   }
88150 }
88151
88152
88153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
88154   void * jresult ;
88155   Dali::Actor *arg1 = 0 ;
88156   int arg2 ;
88157   std::vector< Dali::Actor > *result = 0 ;
88158
88159   arg1 = (Dali::Actor *)jarg1;
88160   if (!arg1) {
88161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88162     return 0;
88163   }
88164   arg2 = (int)jarg2;
88165   {
88166     try {
88167       try {
88168         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
88169       }
88170       catch(std::out_of_range &_e) {
88171         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88172         return 0;
88173       }
88174
88175     } catch (std::out_of_range& e) {
88176       {
88177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88178       };
88179     } catch (std::exception& e) {
88180       {
88181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88182       };
88183     } catch (...) {
88184       {
88185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88186       };
88187     }
88188   }
88189   jresult = (void *)result;
88190   return jresult;
88191 }
88192
88193
88194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
88195   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88196
88197   arg1 = (std::vector< Dali::Actor > *)jarg1;
88198   {
88199     try {
88200       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
88201     } catch (std::out_of_range& e) {
88202       {
88203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88204       };
88205     } catch (std::exception& e) {
88206       {
88207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88208       };
88209     } catch (...) {
88210       {
88211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88212       };
88213     }
88214   }
88215 }
88216
88217
88218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
88219   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88220   int arg2 ;
88221   int arg3 ;
88222
88223   arg1 = (std::vector< Dali::Actor > *)jarg1;
88224   arg2 = (int)jarg2;
88225   arg3 = (int)jarg3;
88226   {
88227     try {
88228       try {
88229         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
88230       }
88231       catch(std::out_of_range &_e) {
88232         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88233         return ;
88234       }
88235       catch(std::invalid_argument &_e) {
88236         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88237         return ;
88238       }
88239
88240     } catch (std::out_of_range& e) {
88241       {
88242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88243       };
88244     } catch (std::exception& e) {
88245       {
88246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88247       };
88248     } catch (...) {
88249       {
88250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88251       };
88252     }
88253   }
88254 }
88255
88256
88257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
88258   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88259   int arg2 ;
88260   std::vector< Dali::Actor > *arg3 = 0 ;
88261
88262   arg1 = (std::vector< Dali::Actor > *)jarg1;
88263   arg2 = (int)jarg2;
88264   arg3 = (std::vector< Dali::Actor > *)jarg3;
88265   if (!arg3) {
88266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
88267     return ;
88268   }
88269   {
88270     try {
88271       try {
88272         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
88273       }
88274       catch(std::out_of_range &_e) {
88275         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88276         return ;
88277       }
88278
88279     } catch (std::out_of_range& e) {
88280       {
88281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88282       };
88283     } catch (std::exception& e) {
88284       {
88285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88286       };
88287     } catch (...) {
88288       {
88289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88290       };
88291     }
88292   }
88293 }
88294
88295
88296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
88297   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88298
88299   arg1 = (std::vector< Dali::Actor > *)jarg1;
88300   {
88301     try {
88302       delete arg1;
88303     } catch (std::out_of_range& e) {
88304       {
88305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88306       };
88307     } catch (std::exception& e) {
88308       {
88309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88310       };
88311     } catch (...) {
88312       {
88313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88314       };
88315     }
88316   }
88317 }
88318
88319
88320 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
88321   unsigned int jresult ;
88322   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88323   bool result;
88324
88325   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88326   {
88327     try {
88328       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
88329     } catch (std::out_of_range& e) {
88330       {
88331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88332       };
88333     } catch (std::exception& e) {
88334       {
88335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88336       };
88337     } catch (...) {
88338       {
88339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88340       };
88341     }
88342   }
88343   jresult = result;
88344   return jresult;
88345 }
88346
88347
88348 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
88349   unsigned long jresult ;
88350   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88351   std::size_t result;
88352
88353   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88354   {
88355     try {
88356       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
88357     } catch (std::out_of_range& e) {
88358       {
88359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88360       };
88361     } catch (std::exception& e) {
88362       {
88363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88364       };
88365     } catch (...) {
88366       {
88367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88368       };
88369     }
88370   }
88371   jresult = (unsigned long)result;
88372   return jresult;
88373 }
88374
88375
88376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
88377   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88378   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
88379
88380   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88381   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
88382   {
88383     try {
88384       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
88385     } catch (std::out_of_range& e) {
88386       {
88387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88388       };
88389     } catch (std::exception& e) {
88390       {
88391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88392       };
88393     } catch (...) {
88394       {
88395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88396       };
88397     }
88398   }
88399 }
88400
88401
88402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
88403   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88404   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
88405
88406   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88407   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
88408   {
88409     try {
88410       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
88411     } catch (std::out_of_range& e) {
88412       {
88413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88414       };
88415     } catch (std::exception& e) {
88416       {
88417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88418       };
88419     } catch (...) {
88420       {
88421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88422       };
88423     }
88424   }
88425 }
88426
88427
88428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
88429   unsigned int jresult ;
88430   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88431   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
88432   bool result;
88433
88434   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88435   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
88436   if (!arg2) {
88437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
88438     return 0;
88439   }
88440   {
88441     try {
88442       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
88443     } catch (std::out_of_range& e) {
88444       {
88445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88446       };
88447     } catch (std::exception& e) {
88448       {
88449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88450       };
88451     } catch (...) {
88452       {
88453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88454       };
88455     }
88456   }
88457   jresult = result;
88458   return jresult;
88459 }
88460
88461
88462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
88463   void * jresult ;
88464   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
88465
88466   {
88467     try {
88468       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
88469     } catch (std::out_of_range& e) {
88470       {
88471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88472       };
88473     } catch (std::exception& e) {
88474       {
88475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88476       };
88477     } catch (...) {
88478       {
88479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88480       };
88481     }
88482   }
88483   jresult = (void *)result;
88484   return jresult;
88485 }
88486
88487
88488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
88489   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88490
88491   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88492   {
88493     try {
88494       delete arg1;
88495     } catch (std::out_of_range& e) {
88496       {
88497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88498       };
88499     } catch (std::exception& e) {
88500       {
88501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88502       };
88503     } catch (...) {
88504       {
88505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88506       };
88507     }
88508   }
88509 }
88510
88511
88512 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
88513   unsigned int jresult ;
88514   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88515   bool result;
88516
88517   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88518   {
88519     try {
88520       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);
88521     } catch (std::out_of_range& e) {
88522       {
88523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88524       };
88525     } catch (std::exception& e) {
88526       {
88527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88528       };
88529     } catch (...) {
88530       {
88531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88532       };
88533     }
88534   }
88535   jresult = result;
88536   return jresult;
88537 }
88538
88539
88540 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
88541   unsigned long jresult ;
88542   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88543   std::size_t result;
88544
88545   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88546   {
88547     try {
88548       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);
88549     } catch (std::out_of_range& e) {
88550       {
88551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88552       };
88553     } catch (std::exception& e) {
88554       {
88555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88556       };
88557     } catch (...) {
88558       {
88559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88560       };
88561     }
88562   }
88563   jresult = (unsigned long)result;
88564   return jresult;
88565 }
88566
88567
88568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
88569   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88570   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
88571
88572   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88573   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
88574   {
88575     try {
88576       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
88577     } catch (std::out_of_range& e) {
88578       {
88579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88580       };
88581     } catch (std::exception& e) {
88582       {
88583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88584       };
88585     } catch (...) {
88586       {
88587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88588       };
88589     }
88590   }
88591 }
88592
88593
88594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
88595   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88596   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
88597
88598   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88599   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
88600   {
88601     try {
88602       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
88603     } catch (std::out_of_range& e) {
88604       {
88605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88606       };
88607     } catch (std::exception& e) {
88608       {
88609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88610       };
88611     } catch (...) {
88612       {
88613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88614       };
88615     }
88616   }
88617 }
88618
88619
88620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
88621   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88622   Dali::Actor arg2 ;
88623   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
88624   Dali::Actor *argp2 ;
88625
88626   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88627   argp2 = (Dali::Actor *)jarg2;
88628   if (!argp2) {
88629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88630     return ;
88631   }
88632   arg2 = *argp2;
88633   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
88634   {
88635     try {
88636       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
88637     } catch (std::out_of_range& e) {
88638       {
88639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88640       };
88641     } catch (std::exception& e) {
88642       {
88643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88644       };
88645     } catch (...) {
88646       {
88647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88648       };
88649     }
88650   }
88651 }
88652
88653
88654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
88655   void * jresult ;
88656   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
88657
88658   {
88659     try {
88660       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
88661     } catch (std::out_of_range& e) {
88662       {
88663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88664       };
88665     } catch (std::exception& e) {
88666       {
88667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88668       };
88669     } catch (...) {
88670       {
88671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88672       };
88673     }
88674   }
88675   jresult = (void *)result;
88676   return jresult;
88677 }
88678
88679
88680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
88681   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88682
88683   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88684   {
88685     try {
88686       delete arg1;
88687     } catch (std::out_of_range& e) {
88688       {
88689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88690       };
88691     } catch (std::exception& e) {
88692       {
88693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88694       };
88695     } catch (...) {
88696       {
88697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88698       };
88699     }
88700   }
88701 }
88702
88703
88704 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
88705   unsigned int jresult ;
88706   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88707   bool result;
88708
88709   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88710   {
88711     try {
88712       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
88713     } catch (std::out_of_range& e) {
88714       {
88715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88716       };
88717     } catch (std::exception& e) {
88718       {
88719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88720       };
88721     } catch (...) {
88722       {
88723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88724       };
88725     }
88726   }
88727   jresult = result;
88728   return jresult;
88729 }
88730
88731
88732 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
88733   unsigned long jresult ;
88734   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88735   std::size_t result;
88736
88737   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88738   {
88739     try {
88740       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
88741     } catch (std::out_of_range& e) {
88742       {
88743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88744       };
88745     } catch (std::exception& e) {
88746       {
88747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88748       };
88749     } catch (...) {
88750       {
88751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88752       };
88753     }
88754   }
88755   jresult = (unsigned long)result;
88756   return jresult;
88757 }
88758
88759
88760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
88761   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88762   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
88763
88764   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88765   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
88766   {
88767     try {
88768       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
88769     } catch (std::out_of_range& e) {
88770       {
88771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88772       };
88773     } catch (std::exception& e) {
88774       {
88775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88776       };
88777     } catch (...) {
88778       {
88779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88780       };
88781     }
88782   }
88783 }
88784
88785
88786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
88787   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88788   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
88789
88790   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88791   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
88792   {
88793     try {
88794       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
88795     } catch (std::out_of_range& e) {
88796       {
88797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88798       };
88799     } catch (std::exception& e) {
88800       {
88801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88802       };
88803     } catch (...) {
88804       {
88805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88806       };
88807     }
88808   }
88809 }
88810
88811
88812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
88813   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88814   Dali::Actor arg2 ;
88815   Dali::Actor arg3 ;
88816   Dali::Actor *argp2 ;
88817   Dali::Actor *argp3 ;
88818
88819   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88820   argp2 = (Dali::Actor *)jarg2;
88821   if (!argp2) {
88822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88823     return ;
88824   }
88825   arg2 = *argp2;
88826   argp3 = (Dali::Actor *)jarg3;
88827   if (!argp3) {
88828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88829     return ;
88830   }
88831   arg3 = *argp3;
88832   {
88833     try {
88834       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
88835     } catch (std::out_of_range& e) {
88836       {
88837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88838       };
88839     } catch (std::exception& e) {
88840       {
88841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88842       };
88843     } catch (...) {
88844       {
88845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88846       };
88847     }
88848   }
88849 }
88850
88851
88852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
88853   void * jresult ;
88854   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
88855
88856   {
88857     try {
88858       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
88859     } catch (std::out_of_range& e) {
88860       {
88861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88862       };
88863     } catch (std::exception& e) {
88864       {
88865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88866       };
88867     } catch (...) {
88868       {
88869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88870       };
88871     }
88872   }
88873   jresult = (void *)result;
88874   return jresult;
88875 }
88876
88877
88878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
88879   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88880
88881   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88882   {
88883     try {
88884       delete arg1;
88885     } catch (std::out_of_range& e) {
88886       {
88887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88888       };
88889     } catch (std::exception& e) {
88890       {
88891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88892       };
88893     } catch (...) {
88894       {
88895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88896       };
88897     }
88898   }
88899 }
88900
88901
88902 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
88903   unsigned int jresult ;
88904   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88905   bool result;
88906
88907   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88908   {
88909     try {
88910       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
88911     } catch (std::out_of_range& e) {
88912       {
88913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88914       };
88915     } catch (std::exception& e) {
88916       {
88917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88918       };
88919     } catch (...) {
88920       {
88921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88922       };
88923     }
88924   }
88925   jresult = result;
88926   return jresult;
88927 }
88928
88929
88930 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
88931   unsigned long jresult ;
88932   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88933   std::size_t result;
88934
88935   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88936   {
88937     try {
88938       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
88939     } catch (std::out_of_range& e) {
88940       {
88941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88942       };
88943     } catch (std::exception& e) {
88944       {
88945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88946       };
88947     } catch (...) {
88948       {
88949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88950       };
88951     }
88952   }
88953   jresult = (unsigned long)result;
88954   return jresult;
88955 }
88956
88957
88958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
88959   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88960   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
88961
88962   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88963   arg2 = (void (*)(Dali::Actor,bool))jarg2;
88964   {
88965     try {
88966       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
88967     } catch (std::out_of_range& e) {
88968       {
88969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88970       };
88971     } catch (std::exception& e) {
88972       {
88973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88974       };
88975     } catch (...) {
88976       {
88977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88978       };
88979     }
88980   }
88981 }
88982
88983
88984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
88985   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88986   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
88987
88988   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88989   arg2 = (void (*)(Dali::Actor,bool))jarg2;
88990   {
88991     try {
88992       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
88993     } catch (std::out_of_range& e) {
88994       {
88995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88996       };
88997     } catch (std::exception& e) {
88998       {
88999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89000       };
89001     } catch (...) {
89002       {
89003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89004       };
89005     }
89006   }
89007 }
89008
89009
89010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
89011   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89012   Dali::Actor arg2 ;
89013   bool arg3 ;
89014   Dali::Actor *argp2 ;
89015
89016   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89017   argp2 = (Dali::Actor *)jarg2;
89018   if (!argp2) {
89019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89020     return ;
89021   }
89022   arg2 = *argp2;
89023   arg3 = jarg3 ? true : false;
89024   {
89025     try {
89026       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
89027     } catch (std::out_of_range& e) {
89028       {
89029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89030       };
89031     } catch (std::exception& e) {
89032       {
89033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89034       };
89035     } catch (...) {
89036       {
89037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89038       };
89039     }
89040   }
89041 }
89042
89043
89044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
89045   void * jresult ;
89046   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
89047
89048   {
89049     try {
89050       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
89051     } catch (std::out_of_range& e) {
89052       {
89053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89054       };
89055     } catch (std::exception& e) {
89056       {
89057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89058       };
89059     } catch (...) {
89060       {
89061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89062       };
89063     }
89064   }
89065   jresult = (void *)result;
89066   return jresult;
89067 }
89068
89069
89070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
89071   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89072
89073   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89074   {
89075     try {
89076       delete arg1;
89077     } catch (std::out_of_range& e) {
89078       {
89079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89080       };
89081     } catch (std::exception& e) {
89082       {
89083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89084       };
89085     } catch (...) {
89086       {
89087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89088       };
89089     }
89090   }
89091 }
89092
89093
89094 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
89095   unsigned int jresult ;
89096   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89097   bool result;
89098
89099   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89100   {
89101     try {
89102       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);
89103     } catch (std::out_of_range& e) {
89104       {
89105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89106       };
89107     } catch (std::exception& e) {
89108       {
89109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89110       };
89111     } catch (...) {
89112       {
89113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89114       };
89115     }
89116   }
89117   jresult = result;
89118   return jresult;
89119 }
89120
89121
89122 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
89123   unsigned long jresult ;
89124   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89125   std::size_t result;
89126
89127   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89128   {
89129     try {
89130       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);
89131     } catch (std::out_of_range& e) {
89132       {
89133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89134       };
89135     } catch (std::exception& e) {
89136       {
89137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89138       };
89139     } catch (...) {
89140       {
89141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89142       };
89143     }
89144   }
89145   jresult = (unsigned long)result;
89146   return jresult;
89147 }
89148
89149
89150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
89151   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89152   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
89153
89154   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89155   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
89156   {
89157     try {
89158       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
89159     } catch (std::out_of_range& e) {
89160       {
89161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89162       };
89163     } catch (std::exception& e) {
89164       {
89165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89166       };
89167     } catch (...) {
89168       {
89169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89170       };
89171     }
89172   }
89173 }
89174
89175
89176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
89177   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89178   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
89179
89180   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89181   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
89182   {
89183     try {
89184       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
89185     } catch (std::out_of_range& e) {
89186       {
89187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89188       };
89189     } catch (std::exception& e) {
89190       {
89191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89192       };
89193     } catch (...) {
89194       {
89195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89196       };
89197     }
89198   }
89199 }
89200
89201
89202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
89203   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89204   Dali::Toolkit::StyleManager arg2 ;
89205   Dali::StyleChange::Type arg3 ;
89206   Dali::Toolkit::StyleManager *argp2 ;
89207
89208   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89209   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
89210   if (!argp2) {
89211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
89212     return ;
89213   }
89214   arg2 = *argp2;
89215   arg3 = (Dali::StyleChange::Type)jarg3;
89216   {
89217     try {
89218       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
89219     } catch (std::out_of_range& e) {
89220       {
89221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89222       };
89223     } catch (std::exception& e) {
89224       {
89225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89226       };
89227     } catch (...) {
89228       {
89229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89230       };
89231     }
89232   }
89233 }
89234
89235
89236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
89237   void * jresult ;
89238   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
89239
89240   {
89241     try {
89242       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
89243     } catch (std::out_of_range& e) {
89244       {
89245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89246       };
89247     } catch (std::exception& e) {
89248       {
89249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89250       };
89251     } catch (...) {
89252       {
89253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89254       };
89255     }
89256   }
89257   jresult = (void *)result;
89258   return jresult;
89259 }
89260
89261
89262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
89263   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89264
89265   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89266   {
89267     try {
89268       delete arg1;
89269     } catch (std::out_of_range& e) {
89270       {
89271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89272       };
89273     } catch (std::exception& e) {
89274       {
89275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89276       };
89277     } catch (...) {
89278       {
89279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89280       };
89281     }
89282   }
89283 }
89284
89285
89286 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
89287   unsigned int jresult ;
89288   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89289   bool result;
89290
89291   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89292   {
89293     try {
89294       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
89295     } catch (std::out_of_range& e) {
89296       {
89297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89298       };
89299     } catch (std::exception& e) {
89300       {
89301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89302       };
89303     } catch (...) {
89304       {
89305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89306       };
89307     }
89308   }
89309   jresult = result;
89310   return jresult;
89311 }
89312
89313
89314 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
89315   unsigned long jresult ;
89316   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89317   std::size_t result;
89318
89319   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89320   {
89321     try {
89322       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
89323     } catch (std::out_of_range& e) {
89324       {
89325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89326       };
89327     } catch (std::exception& e) {
89328       {
89329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89330       };
89331     } catch (...) {
89332       {
89333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89334       };
89335     }
89336   }
89337   jresult = (unsigned long)result;
89338   return jresult;
89339 }
89340
89341
89342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
89343   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89344   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
89345
89346   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89347   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
89348   {
89349     try {
89350       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
89351     } catch (std::out_of_range& e) {
89352       {
89353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89354       };
89355     } catch (std::exception& e) {
89356       {
89357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89358       };
89359     } catch (...) {
89360       {
89361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89362       };
89363     }
89364   }
89365 }
89366
89367
89368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
89369   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89370   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
89371
89372   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89373   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
89374   {
89375     try {
89376       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
89377     } catch (std::out_of_range& e) {
89378       {
89379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89380       };
89381     } catch (std::exception& e) {
89382       {
89383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89384       };
89385     } catch (...) {
89386       {
89387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89388       };
89389     }
89390   }
89391 }
89392
89393
89394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
89395   unsigned int jresult ;
89396   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89397   Dali::Toolkit::Button arg2 ;
89398   Dali::Toolkit::Button *argp2 ;
89399   bool result;
89400
89401   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89402   argp2 = (Dali::Toolkit::Button *)jarg2;
89403   if (!argp2) {
89404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
89405     return 0;
89406   }
89407   arg2 = *argp2;
89408   {
89409     try {
89410       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
89411     } catch (std::out_of_range& e) {
89412       {
89413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89414       };
89415     } catch (std::exception& e) {
89416       {
89417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89418       };
89419     } catch (...) {
89420       {
89421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89422       };
89423     }
89424   }
89425   jresult = result;
89426   return jresult;
89427 }
89428
89429
89430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
89431   void * jresult ;
89432   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
89433
89434   {
89435     try {
89436       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
89437     } catch (std::out_of_range& e) {
89438       {
89439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89440       };
89441     } catch (std::exception& e) {
89442       {
89443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89444       };
89445     } catch (...) {
89446       {
89447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89448       };
89449     }
89450   }
89451   jresult = (void *)result;
89452   return jresult;
89453 }
89454
89455
89456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
89457   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89458
89459   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89460   {
89461     try {
89462       delete arg1;
89463     } catch (std::out_of_range& e) {
89464       {
89465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89466       };
89467     } catch (std::exception& e) {
89468       {
89469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89470       };
89471     } catch (...) {
89472       {
89473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89474       };
89475     }
89476   }
89477 }
89478
89479
89480 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
89481   unsigned int jresult ;
89482   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89483   bool result;
89484
89485   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89486   {
89487     try {
89488       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
89489     } catch (std::out_of_range& e) {
89490       {
89491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89492       };
89493     } catch (std::exception& e) {
89494       {
89495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89496       };
89497     } catch (...) {
89498       {
89499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89500       };
89501     }
89502   }
89503   jresult = result;
89504   return jresult;
89505 }
89506
89507
89508 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
89509   unsigned long jresult ;
89510   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89511   std::size_t result;
89512
89513   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89514   {
89515     try {
89516       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
89517     } catch (std::out_of_range& e) {
89518       {
89519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89520       };
89521     } catch (std::exception& e) {
89522       {
89523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89524       };
89525     } catch (...) {
89526       {
89527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89528       };
89529     }
89530   }
89531   jresult = (unsigned long)result;
89532   return jresult;
89533 }
89534
89535
89536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
89537   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89538   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
89539
89540   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89541   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
89542   {
89543     try {
89544       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
89545     } catch (std::out_of_range& e) {
89546       {
89547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89548       };
89549     } catch (std::exception& e) {
89550       {
89551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89552       };
89553     } catch (...) {
89554       {
89555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89556       };
89557     }
89558   }
89559 }
89560
89561
89562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
89563   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89564   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
89565
89566   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89567   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
89568   {
89569     try {
89570       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
89571     } catch (std::out_of_range& e) {
89572       {
89573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89574       };
89575     } catch (std::exception& e) {
89576       {
89577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89578       };
89579     } catch (...) {
89580       {
89581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89582       };
89583     }
89584   }
89585 }
89586
89587
89588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
89589   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89590   Dali::Toolkit::GaussianBlurView arg2 ;
89591   Dali::Toolkit::GaussianBlurView *argp2 ;
89592
89593   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89594   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
89595   if (!argp2) {
89596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
89597     return ;
89598   }
89599   arg2 = *argp2;
89600   {
89601     try {
89602       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
89603     } catch (std::out_of_range& e) {
89604       {
89605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89606       };
89607     } catch (std::exception& e) {
89608       {
89609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89610       };
89611     } catch (...) {
89612       {
89613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89614       };
89615     }
89616   }
89617 }
89618
89619
89620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
89621   void * jresult ;
89622   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
89623
89624   {
89625     try {
89626       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
89627     } catch (std::out_of_range& e) {
89628       {
89629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89630       };
89631     } catch (std::exception& e) {
89632       {
89633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89634       };
89635     } catch (...) {
89636       {
89637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89638       };
89639     }
89640   }
89641   jresult = (void *)result;
89642   return jresult;
89643 }
89644
89645
89646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
89647   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89648
89649   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89650   {
89651     try {
89652       delete arg1;
89653     } catch (std::out_of_range& e) {
89654       {
89655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89656       };
89657     } catch (std::exception& e) {
89658       {
89659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89660       };
89661     } catch (...) {
89662       {
89663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89664       };
89665     }
89666   }
89667 }
89668
89669
89670 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
89671   unsigned int jresult ;
89672   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89673   bool result;
89674
89675   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89676   {
89677     try {
89678       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);
89679     } catch (std::out_of_range& e) {
89680       {
89681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89682       };
89683     } catch (std::exception& e) {
89684       {
89685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89686       };
89687     } catch (...) {
89688       {
89689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89690       };
89691     }
89692   }
89693   jresult = result;
89694   return jresult;
89695 }
89696
89697
89698 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
89699   unsigned long jresult ;
89700   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89701   std::size_t result;
89702
89703   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89704   {
89705     try {
89706       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);
89707     } catch (std::out_of_range& e) {
89708       {
89709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89710       };
89711     } catch (std::exception& e) {
89712       {
89713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89714       };
89715     } catch (...) {
89716       {
89717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89718       };
89719     }
89720   }
89721   jresult = (unsigned long)result;
89722   return jresult;
89723 }
89724
89725
89726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
89727   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89728   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
89729
89730   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89731   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
89732   {
89733     try {
89734       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
89735     } catch (std::out_of_range& e) {
89736       {
89737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89738       };
89739     } catch (std::exception& e) {
89740       {
89741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89742       };
89743     } catch (...) {
89744       {
89745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89746       };
89747     }
89748   }
89749 }
89750
89751
89752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
89753   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89754   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
89755
89756   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89757   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
89758   {
89759     try {
89760       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
89761     } catch (std::out_of_range& e) {
89762       {
89763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89764       };
89765     } catch (std::exception& e) {
89766       {
89767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89768       };
89769     } catch (...) {
89770       {
89771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89772       };
89773     }
89774   }
89775 }
89776
89777
89778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
89779   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89780   Dali::Toolkit::PageTurnView arg2 ;
89781   unsigned int arg3 ;
89782   bool arg4 ;
89783   Dali::Toolkit::PageTurnView *argp2 ;
89784
89785   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89786   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
89787   if (!argp2) {
89788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
89789     return ;
89790   }
89791   arg2 = *argp2;
89792   arg3 = (unsigned int)jarg3;
89793   arg4 = jarg4 ? true : false;
89794   {
89795     try {
89796       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
89797     } catch (std::out_of_range& e) {
89798       {
89799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89800       };
89801     } catch (std::exception& e) {
89802       {
89803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89804       };
89805     } catch (...) {
89806       {
89807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89808       };
89809     }
89810   }
89811 }
89812
89813
89814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
89815   void * jresult ;
89816   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
89817
89818   {
89819     try {
89820       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
89821     } catch (std::out_of_range& e) {
89822       {
89823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89824       };
89825     } catch (std::exception& e) {
89826       {
89827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89828       };
89829     } catch (...) {
89830       {
89831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89832       };
89833     }
89834   }
89835   jresult = (void *)result;
89836   return jresult;
89837 }
89838
89839
89840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
89841   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89842
89843   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89844   {
89845     try {
89846       delete arg1;
89847     } catch (std::out_of_range& e) {
89848       {
89849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89850       };
89851     } catch (std::exception& e) {
89852       {
89853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89854       };
89855     } catch (...) {
89856       {
89857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89858       };
89859     }
89860   }
89861 }
89862
89863
89864 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
89865   unsigned int jresult ;
89866   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89867   bool result;
89868
89869   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89870   {
89871     try {
89872       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
89873     } catch (std::out_of_range& e) {
89874       {
89875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89876       };
89877     } catch (std::exception& e) {
89878       {
89879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89880       };
89881     } catch (...) {
89882       {
89883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89884       };
89885     }
89886   }
89887   jresult = result;
89888   return jresult;
89889 }
89890
89891
89892 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
89893   unsigned long jresult ;
89894   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89895   std::size_t result;
89896
89897   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89898   {
89899     try {
89900       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
89901     } catch (std::out_of_range& e) {
89902       {
89903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89904       };
89905     } catch (std::exception& e) {
89906       {
89907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89908       };
89909     } catch (...) {
89910       {
89911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89912       };
89913     }
89914   }
89915   jresult = (unsigned long)result;
89916   return jresult;
89917 }
89918
89919
89920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
89921   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89922   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
89923
89924   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89925   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
89926   {
89927     try {
89928       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
89929     } catch (std::out_of_range& e) {
89930       {
89931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89932       };
89933     } catch (std::exception& e) {
89934       {
89935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89936       };
89937     } catch (...) {
89938       {
89939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89940       };
89941     }
89942   }
89943 }
89944
89945
89946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
89947   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89948   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
89949
89950   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89951   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
89952   {
89953     try {
89954       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
89955     } catch (std::out_of_range& e) {
89956       {
89957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89958       };
89959     } catch (std::exception& e) {
89960       {
89961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89962       };
89963     } catch (...) {
89964       {
89965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89966       };
89967     }
89968   }
89969 }
89970
89971
89972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
89973   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89974   Dali::Toolkit::PageTurnView arg2 ;
89975   Dali::Toolkit::PageTurnView *argp2 ;
89976
89977   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89978   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
89979   if (!argp2) {
89980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
89981     return ;
89982   }
89983   arg2 = *argp2;
89984   {
89985     try {
89986       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
89987     } catch (std::out_of_range& e) {
89988       {
89989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89990       };
89991     } catch (std::exception& e) {
89992       {
89993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89994       };
89995     } catch (...) {
89996       {
89997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89998       };
89999     }
90000   }
90001 }
90002
90003
90004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
90005   void * jresult ;
90006   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
90007
90008   {
90009     try {
90010       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
90011     } catch (std::out_of_range& e) {
90012       {
90013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90014       };
90015     } catch (std::exception& e) {
90016       {
90017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90018       };
90019     } catch (...) {
90020       {
90021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90022       };
90023     }
90024   }
90025   jresult = (void *)result;
90026   return jresult;
90027 }
90028
90029
90030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
90031   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90032
90033   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90034   {
90035     try {
90036       delete arg1;
90037     } catch (std::out_of_range& e) {
90038       {
90039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90040       };
90041     } catch (std::exception& e) {
90042       {
90043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90044       };
90045     } catch (...) {
90046       {
90047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90048       };
90049     }
90050   }
90051 }
90052
90053
90054 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
90055   unsigned int jresult ;
90056   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
90057   bool result;
90058
90059   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
90060   {
90061     try {
90062       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);
90063     } catch (std::out_of_range& e) {
90064       {
90065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90066       };
90067     } catch (std::exception& e) {
90068       {
90069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90070       };
90071     } catch (...) {
90072       {
90073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90074       };
90075     }
90076   }
90077   jresult = result;
90078   return jresult;
90079 }
90080
90081
90082 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
90083   unsigned long jresult ;
90084   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
90085   std::size_t result;
90086
90087   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
90088   {
90089     try {
90090       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);
90091     } catch (std::out_of_range& e) {
90092       {
90093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90094       };
90095     } catch (std::exception& e) {
90096       {
90097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90098       };
90099     } catch (...) {
90100       {
90101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90102       };
90103     }
90104   }
90105   jresult = (unsigned long)result;
90106   return jresult;
90107 }
90108
90109
90110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
90111   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
90112   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
90113
90114   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
90115   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
90116   {
90117     try {
90118       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
90119     } catch (std::out_of_range& e) {
90120       {
90121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90122       };
90123     } catch (std::exception& e) {
90124       {
90125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90126       };
90127     } catch (...) {
90128       {
90129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90130       };
90131     }
90132   }
90133 }
90134
90135
90136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90137   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
90138   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
90139
90140   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
90141   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
90142   {
90143     try {
90144       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
90145     } catch (std::out_of_range& e) {
90146       {
90147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90148       };
90149     } catch (std::exception& e) {
90150       {
90151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90152       };
90153     } catch (...) {
90154       {
90155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90156       };
90157     }
90158   }
90159 }
90160
90161
90162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
90163   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
90164   Dali::Toolkit::ProgressBar arg2 ;
90165   float arg3 ;
90166   float arg4 ;
90167   Dali::Toolkit::ProgressBar *argp2 ;
90168
90169   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
90170   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
90171   if (!argp2) {
90172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
90173     return ;
90174   }
90175   arg2 = *argp2;
90176   arg3 = (float)jarg3;
90177   arg4 = (float)jarg4;
90178   {
90179     try {
90180       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
90181     } catch (std::out_of_range& e) {
90182       {
90183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90184       };
90185     } catch (std::exception& e) {
90186       {
90187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90188       };
90189     } catch (...) {
90190       {
90191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90192       };
90193     }
90194   }
90195 }
90196
90197
90198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
90199   void * jresult ;
90200   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
90201
90202   {
90203     try {
90204       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
90205     } catch (std::out_of_range& e) {
90206       {
90207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90208       };
90209     } catch (std::exception& e) {
90210       {
90211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90212       };
90213     } catch (...) {
90214       {
90215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90216       };
90217     }
90218   }
90219   jresult = (void *)result;
90220   return jresult;
90221 }
90222
90223
90224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
90225   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
90226
90227   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
90228   {
90229     try {
90230       delete arg1;
90231     } catch (std::out_of_range& e) {
90232       {
90233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90234       };
90235     } catch (std::exception& e) {
90236       {
90237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90238       };
90239     } catch (...) {
90240       {
90241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90242       };
90243     }
90244   }
90245 }
90246
90247
90248 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
90249   unsigned int jresult ;
90250   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90251   bool result;
90252
90253   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90254   {
90255     try {
90256       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);
90257     } catch (std::out_of_range& e) {
90258       {
90259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90260       };
90261     } catch (std::exception& e) {
90262       {
90263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90264       };
90265     } catch (...) {
90266       {
90267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90268       };
90269     }
90270   }
90271   jresult = result;
90272   return jresult;
90273 }
90274
90275
90276 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
90277   unsigned long jresult ;
90278   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90279   std::size_t result;
90280
90281   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90282   {
90283     try {
90284       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);
90285     } catch (std::out_of_range& e) {
90286       {
90287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90288       };
90289     } catch (std::exception& e) {
90290       {
90291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90292       };
90293     } catch (...) {
90294       {
90295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90296       };
90297     }
90298   }
90299   jresult = (unsigned long)result;
90300   return jresult;
90301 }
90302
90303
90304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
90305   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90306   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
90307
90308   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90309   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
90310   {
90311     try {
90312       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
90313     } catch (std::out_of_range& e) {
90314       {
90315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90316       };
90317     } catch (std::exception& e) {
90318       {
90319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90320       };
90321     } catch (...) {
90322       {
90323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90324       };
90325     }
90326   }
90327 }
90328
90329
90330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
90331   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90332   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
90333
90334   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90335   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
90336   {
90337     try {
90338       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
90339     } catch (std::out_of_range& e) {
90340       {
90341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90342       };
90343     } catch (std::exception& e) {
90344       {
90345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90346       };
90347     } catch (...) {
90348       {
90349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90350       };
90351     }
90352   }
90353 }
90354
90355
90356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
90357   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90358   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
90359
90360   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90361   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
90362   if (!arg2) {
90363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
90364     return ;
90365   }
90366   {
90367     try {
90368       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
90369     } catch (std::out_of_range& e) {
90370       {
90371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90372       };
90373     } catch (std::exception& e) {
90374       {
90375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90376       };
90377     } catch (...) {
90378       {
90379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90380       };
90381     }
90382   }
90383 }
90384
90385
90386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
90387   void * jresult ;
90388   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
90389
90390   {
90391     try {
90392       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
90393     } catch (std::out_of_range& e) {
90394       {
90395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90396       };
90397     } catch (std::exception& e) {
90398       {
90399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90400       };
90401     } catch (...) {
90402       {
90403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90404       };
90405     }
90406   }
90407   jresult = (void *)result;
90408   return jresult;
90409 }
90410
90411
90412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
90413   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90414
90415   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90416   {
90417     try {
90418       delete arg1;
90419     } catch (std::out_of_range& e) {
90420       {
90421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90422       };
90423     } catch (std::exception& e) {
90424       {
90425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90426       };
90427     } catch (...) {
90428       {
90429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90430       };
90431     }
90432   }
90433 }
90434
90435
90436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
90437   unsigned int jresult ;
90438   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90439   bool result;
90440
90441   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90442   {
90443     try {
90444       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
90445     } catch (std::out_of_range& e) {
90446       {
90447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90448       };
90449     } catch (std::exception& e) {
90450       {
90451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90452       };
90453     } catch (...) {
90454       {
90455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90456       };
90457     }
90458   }
90459   jresult = result;
90460   return jresult;
90461 }
90462
90463
90464 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
90465   unsigned long jresult ;
90466   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90467   std::size_t result;
90468
90469   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90470   {
90471     try {
90472       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
90473     } catch (std::out_of_range& e) {
90474       {
90475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90476       };
90477     } catch (std::exception& e) {
90478       {
90479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90480       };
90481     } catch (...) {
90482       {
90483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90484       };
90485     }
90486   }
90487   jresult = (unsigned long)result;
90488   return jresult;
90489 }
90490
90491
90492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
90493   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90494   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
90495
90496   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90497   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
90498   {
90499     try {
90500       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
90501     } catch (std::out_of_range& e) {
90502       {
90503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90504       };
90505     } catch (std::exception& e) {
90506       {
90507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90508       };
90509     } catch (...) {
90510       {
90511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90512       };
90513     }
90514   }
90515 }
90516
90517
90518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
90519   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90520   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
90521
90522   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90523   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
90524   {
90525     try {
90526       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
90527     } catch (std::out_of_range& e) {
90528       {
90529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90530       };
90531     } catch (std::exception& e) {
90532       {
90533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90534       };
90535     } catch (...) {
90536       {
90537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90538       };
90539     }
90540   }
90541 }
90542
90543
90544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
90545   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90546   Dali::Vector2 *arg2 = 0 ;
90547
90548   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90549   arg2 = (Dali::Vector2 *)jarg2;
90550   if (!arg2) {
90551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90552     return ;
90553   }
90554   {
90555     try {
90556       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
90557     } catch (std::out_of_range& e) {
90558       {
90559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90560       };
90561     } catch (std::exception& e) {
90562       {
90563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90564       };
90565     } catch (...) {
90566       {
90567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90568       };
90569     }
90570   }
90571 }
90572
90573
90574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
90575   void * jresult ;
90576   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
90577
90578   {
90579     try {
90580       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
90581     } catch (std::out_of_range& e) {
90582       {
90583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90584       };
90585     } catch (std::exception& e) {
90586       {
90587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90588       };
90589     } catch (...) {
90590       {
90591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90592       };
90593     }
90594   }
90595   jresult = (void *)result;
90596   return jresult;
90597 }
90598
90599
90600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
90601   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90602
90603   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90604   {
90605     try {
90606       delete arg1;
90607     } catch (std::out_of_range& e) {
90608       {
90609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90610       };
90611     } catch (std::exception& e) {
90612       {
90613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90614       };
90615     } catch (...) {
90616       {
90617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90618       };
90619     }
90620   }
90621 }
90622
90623
90624 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextEditorSignal_Empty(void * jarg1) {
90625   unsigned int jresult ;
90626   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90627   bool result;
90628
90629   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90630   {
90631     try {
90632       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
90633     } catch (std::out_of_range& e) {
90634       {
90635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90636       };
90637     } catch (std::exception& e) {
90638       {
90639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90640       };
90641     } catch (...) {
90642       {
90643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90644       };
90645     }
90646   }
90647   jresult = result;
90648   return jresult;
90649 }
90650
90651
90652 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextEditorSignal_GetConnectionCount(void * jarg1) {
90653   unsigned long jresult ;
90654   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90655   std::size_t result;
90656
90657   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90658   {
90659     try {
90660       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
90661     } catch (std::out_of_range& e) {
90662       {
90663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90664       };
90665     } catch (std::exception& e) {
90666       {
90667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90668       };
90669     } catch (...) {
90670       {
90671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90672       };
90673     }
90674   }
90675   jresult = (unsigned long)result;
90676   return jresult;
90677 }
90678
90679
90680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Connect(void * jarg1, void * jarg2) {
90681   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90682   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
90683
90684   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90685   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
90686   {
90687     try {
90688       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Connect(arg1,arg2);
90689     } catch (std::out_of_range& e) {
90690       {
90691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90692       };
90693     } catch (std::exception& e) {
90694       {
90695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90696       };
90697     } catch (...) {
90698       {
90699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90700       };
90701     }
90702   }
90703 }
90704
90705
90706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Disconnect(void * jarg1, void * jarg2) {
90707   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90708   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
90709
90710   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90711   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
90712   {
90713     try {
90714       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Disconnect(arg1,arg2);
90715     } catch (std::out_of_range& e) {
90716       {
90717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90718       };
90719     } catch (std::exception& e) {
90720       {
90721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90722       };
90723     } catch (...) {
90724       {
90725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90726       };
90727     }
90728   }
90729 }
90730
90731
90732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Emit(void * jarg1, void * jarg2) {
90733   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90734   Dali::Toolkit::TextEditor arg2 ;
90735   Dali::Toolkit::TextEditor *argp2 ;
90736
90737   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90738   argp2 = (Dali::Toolkit::TextEditor *)jarg2;
90739   if (!argp2) {
90740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextEditor", 0);
90741     return ;
90742   }
90743   arg2 = *argp2;
90744   {
90745     try {
90746       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(arg1,arg2);
90747     } catch (std::out_of_range& e) {
90748       {
90749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90750       };
90751     } catch (std::exception& e) {
90752       {
90753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90754       };
90755     } catch (...) {
90756       {
90757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90758       };
90759     }
90760   }
90761 }
90762
90763
90764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditorSignal() {
90765   void * jresult ;
90766   Dali::Signal< void (Dali::Toolkit::TextEditor) > *result = 0 ;
90767
90768   {
90769     try {
90770       result = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)new Dali::Signal< void (Dali::Toolkit::TextEditor) >();
90771     } catch (std::out_of_range& e) {
90772       {
90773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90774       };
90775     } catch (std::exception& e) {
90776       {
90777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90778       };
90779     } catch (...) {
90780       {
90781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90782       };
90783     }
90784   }
90785   jresult = (void *)result;
90786   return jresult;
90787 }
90788
90789
90790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditorSignal(void * jarg1) {
90791   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90792
90793   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90794   {
90795     try {
90796       delete arg1;
90797     } catch (std::out_of_range& e) {
90798       {
90799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90800       };
90801     } catch (std::exception& e) {
90802       {
90803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90804       };
90805     } catch (...) {
90806       {
90807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90808       };
90809     }
90810   }
90811 }
90812
90813
90814 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextFieldSignal_Empty(void * jarg1) {
90815   unsigned int jresult ;
90816   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90817   bool result;
90818
90819   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90820   {
90821     try {
90822       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
90823     } catch (std::out_of_range& e) {
90824       {
90825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90826       };
90827     } catch (std::exception& e) {
90828       {
90829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90830       };
90831     } catch (...) {
90832       {
90833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90834       };
90835     }
90836   }
90837   jresult = result;
90838   return jresult;
90839 }
90840
90841
90842 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextFieldSignal_GetConnectionCount(void * jarg1) {
90843   unsigned long jresult ;
90844   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90845   std::size_t result;
90846
90847   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90848   {
90849     try {
90850       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
90851     } catch (std::out_of_range& e) {
90852       {
90853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90854       };
90855     } catch (std::exception& e) {
90856       {
90857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90858       };
90859     } catch (...) {
90860       {
90861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90862       };
90863     }
90864   }
90865   jresult = (unsigned long)result;
90866   return jresult;
90867 }
90868
90869
90870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Connect(void * jarg1, void * jarg2) {
90871   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90872   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
90873
90874   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90875   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
90876   {
90877     try {
90878       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Connect(arg1,arg2);
90879     } catch (std::out_of_range& e) {
90880       {
90881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90882       };
90883     } catch (std::exception& e) {
90884       {
90885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90886       };
90887     } catch (...) {
90888       {
90889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90890       };
90891     }
90892   }
90893 }
90894
90895
90896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Disconnect(void * jarg1, void * jarg2) {
90897   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90898   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
90899
90900   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90901   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
90902   {
90903     try {
90904       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Disconnect(arg1,arg2);
90905     } catch (std::out_of_range& e) {
90906       {
90907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90908       };
90909     } catch (std::exception& e) {
90910       {
90911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90912       };
90913     } catch (...) {
90914       {
90915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90916       };
90917     }
90918   }
90919 }
90920
90921
90922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Emit(void * jarg1, void * jarg2) {
90923   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90924   Dali::Toolkit::TextField arg2 ;
90925   Dali::Toolkit::TextField *argp2 ;
90926
90927   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90928   argp2 = (Dali::Toolkit::TextField *)jarg2;
90929   if (!argp2) {
90930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextField", 0);
90931     return ;
90932   }
90933   arg2 = *argp2;
90934   {
90935     try {
90936       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(arg1,arg2);
90937     } catch (std::out_of_range& e) {
90938       {
90939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90940       };
90941     } catch (std::exception& e) {
90942       {
90943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90944       };
90945     } catch (...) {
90946       {
90947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90948       };
90949     }
90950   }
90951 }
90952
90953
90954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextFieldSignal() {
90955   void * jresult ;
90956   Dali::Signal< void (Dali::Toolkit::TextField) > *result = 0 ;
90957
90958   {
90959     try {
90960       result = (Dali::Signal< void (Dali::Toolkit::TextField) > *)new Dali::Signal< void (Dali::Toolkit::TextField) >();
90961     } catch (std::out_of_range& e) {
90962       {
90963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90964       };
90965     } catch (std::exception& e) {
90966       {
90967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90968       };
90969     } catch (...) {
90970       {
90971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90972       };
90973     }
90974   }
90975   jresult = (void *)result;
90976   return jresult;
90977 }
90978
90979
90980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextFieldSignal(void * jarg1) {
90981   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90982
90983   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90984   {
90985     try {
90986       delete arg1;
90987     } catch (std::out_of_range& e) {
90988       {
90989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90990       };
90991     } catch (std::exception& e) {
90992       {
90993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90994       };
90995     } catch (...) {
90996       {
90997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90998       };
90999     }
91000   }
91001 }
91002
91003
91004 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
91005   unsigned int jresult ;
91006   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91007   bool result;
91008
91009   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91010   {
91011     try {
91012       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);
91013     } catch (std::out_of_range& e) {
91014       {
91015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91016       };
91017     } catch (std::exception& e) {
91018       {
91019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91020       };
91021     } catch (...) {
91022       {
91023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91024       };
91025     }
91026   }
91027   jresult = result;
91028   return jresult;
91029 }
91030
91031
91032 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
91033   unsigned long jresult ;
91034   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91035   std::size_t result;
91036
91037   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91038   {
91039     try {
91040       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);
91041     } catch (std::out_of_range& e) {
91042       {
91043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91044       };
91045     } catch (std::exception& e) {
91046       {
91047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91048       };
91049     } catch (...) {
91050       {
91051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91052       };
91053     }
91054   }
91055   jresult = (unsigned long)result;
91056   return jresult;
91057 }
91058
91059
91060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
91061   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91062   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
91063
91064   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91065   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
91066   {
91067     try {
91068       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
91069     } catch (std::out_of_range& e) {
91070       {
91071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91072       };
91073     } catch (std::exception& e) {
91074       {
91075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91076       };
91077     } catch (...) {
91078       {
91079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91080       };
91081     }
91082   }
91083 }
91084
91085
91086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
91087   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91088   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
91089
91090   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91091   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
91092   {
91093     try {
91094       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
91095     } catch (std::out_of_range& e) {
91096       {
91097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91098       };
91099     } catch (std::exception& e) {
91100       {
91101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91102       };
91103     } catch (...) {
91104       {
91105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91106       };
91107     }
91108   }
91109 }
91110
91111
91112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
91113   unsigned int jresult ;
91114   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91115   Dali::Toolkit::Control arg2 ;
91116   Dali::KeyEvent *arg3 = 0 ;
91117   Dali::Toolkit::Control *argp2 ;
91118   bool result;
91119
91120   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91121   argp2 = (Dali::Toolkit::Control *)jarg2;
91122   if (!argp2) {
91123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
91124     return 0;
91125   }
91126   arg2 = *argp2;
91127   arg3 = (Dali::KeyEvent *)jarg3;
91128   if (!arg3) {
91129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
91130     return 0;
91131   }
91132   {
91133     try {
91134       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);
91135     } catch (std::out_of_range& e) {
91136       {
91137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91138       };
91139     } catch (std::exception& e) {
91140       {
91141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91142       };
91143     } catch (...) {
91144       {
91145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91146       };
91147     }
91148   }
91149   jresult = result;
91150   return jresult;
91151 }
91152
91153
91154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
91155   void * jresult ;
91156   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
91157
91158   {
91159     try {
91160       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
91161     } catch (std::out_of_range& e) {
91162       {
91163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91164       };
91165     } catch (std::exception& e) {
91166       {
91167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91168       };
91169     } catch (...) {
91170       {
91171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91172       };
91173     }
91174   }
91175   jresult = (void *)result;
91176   return jresult;
91177 }
91178
91179
91180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
91181   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91182
91183   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91184   {
91185     try {
91186       delete arg1;
91187     } catch (std::out_of_range& e) {
91188       {
91189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91190       };
91191     } catch (std::exception& e) {
91192       {
91193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91194       };
91195     } catch (...) {
91196       {
91197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91198       };
91199     }
91200   }
91201 }
91202
91203
91204 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
91205   unsigned int jresult ;
91206   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91207   bool result;
91208
91209   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91210   {
91211     try {
91212       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
91213     } catch (std::out_of_range& e) {
91214       {
91215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91216       };
91217     } catch (std::exception& e) {
91218       {
91219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91220       };
91221     } catch (...) {
91222       {
91223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91224       };
91225     }
91226   }
91227   jresult = result;
91228   return jresult;
91229 }
91230
91231
91232 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
91233   unsigned long jresult ;
91234   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91235   std::size_t result;
91236
91237   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91238   {
91239     try {
91240       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
91241     } catch (std::out_of_range& e) {
91242       {
91243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91244       };
91245     } catch (std::exception& e) {
91246       {
91247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91248       };
91249     } catch (...) {
91250       {
91251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91252       };
91253     }
91254   }
91255   jresult = (unsigned long)result;
91256   return jresult;
91257 }
91258
91259
91260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
91261   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91262   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
91263
91264   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91265   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
91266   {
91267     try {
91268       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
91269     } catch (std::out_of_range& e) {
91270       {
91271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91272       };
91273     } catch (std::exception& e) {
91274       {
91275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91276       };
91277     } catch (...) {
91278       {
91279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91280       };
91281     }
91282   }
91283 }
91284
91285
91286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
91287   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91288   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
91289
91290   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91291   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
91292   {
91293     try {
91294       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
91295     } catch (std::out_of_range& e) {
91296       {
91297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91298       };
91299     } catch (std::exception& e) {
91300       {
91301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91302       };
91303     } catch (...) {
91304       {
91305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91306       };
91307     }
91308   }
91309 }
91310
91311
91312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
91313   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91314   Dali::Toolkit::Control arg2 ;
91315   Dali::Toolkit::Control *argp2 ;
91316
91317   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91318   argp2 = (Dali::Toolkit::Control *)jarg2;
91319   if (!argp2) {
91320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
91321     return ;
91322   }
91323   arg2 = *argp2;
91324   {
91325     try {
91326       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
91327     } catch (std::out_of_range& e) {
91328       {
91329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91330       };
91331     } catch (std::exception& e) {
91332       {
91333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91334       };
91335     } catch (...) {
91336       {
91337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91338       };
91339     }
91340   }
91341 }
91342
91343
91344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
91345   void * jresult ;
91346   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
91347
91348   {
91349     try {
91350       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
91351     } catch (std::out_of_range& e) {
91352       {
91353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91354       };
91355     } catch (std::exception& e) {
91356       {
91357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91358       };
91359     } catch (...) {
91360       {
91361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91362       };
91363     }
91364   }
91365   jresult = (void *)result;
91366   return jresult;
91367 }
91368
91369
91370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
91371   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91372
91373   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91374   {
91375     try {
91376       delete arg1;
91377     } catch (std::out_of_range& e) {
91378       {
91379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91380       };
91381     } catch (std::exception& e) {
91382       {
91383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91384       };
91385     } catch (...) {
91386       {
91387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91388       };
91389     }
91390   }
91391 }
91392
91393
91394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
91395   unsigned int jresult ;
91396   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91397   bool result;
91398
91399   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91400   {
91401     try {
91402       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
91403     } catch (std::out_of_range& e) {
91404       {
91405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91406       };
91407     } catch (std::exception& e) {
91408       {
91409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91410       };
91411     } catch (...) {
91412       {
91413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91414       };
91415     }
91416   }
91417   jresult = result;
91418   return jresult;
91419 }
91420
91421
91422 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
91423   unsigned long jresult ;
91424   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91425   std::size_t result;
91426
91427   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91428   {
91429     try {
91430       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
91431     } catch (std::out_of_range& e) {
91432       {
91433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91434       };
91435     } catch (std::exception& e) {
91436       {
91437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91438       };
91439     } catch (...) {
91440       {
91441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91442       };
91443     }
91444   }
91445   jresult = (unsigned long)result;
91446   return jresult;
91447 }
91448
91449
91450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
91451   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91452   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
91453
91454   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91455   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
91456   {
91457     try {
91458       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
91459     } catch (std::out_of_range& e) {
91460       {
91461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91462       };
91463     } catch (std::exception& e) {
91464       {
91465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91466       };
91467     } catch (...) {
91468       {
91469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91470       };
91471     }
91472   }
91473 }
91474
91475
91476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
91477   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91478   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
91479
91480   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91481   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
91482   {
91483     try {
91484       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
91485     } catch (std::out_of_range& e) {
91486       {
91487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91488       };
91489     } catch (std::exception& e) {
91490       {
91491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91492       };
91493     } catch (...) {
91494       {
91495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91496       };
91497     }
91498   }
91499 }
91500
91501
91502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
91503   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91504   Dali::Toolkit::VideoView *arg2 = 0 ;
91505
91506   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91507   arg2 = (Dali::Toolkit::VideoView *)jarg2;
91508   if (!arg2) {
91509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
91510     return ;
91511   }
91512   {
91513     try {
91514       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
91515     } catch (std::out_of_range& e) {
91516       {
91517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91518       };
91519     } catch (std::exception& e) {
91520       {
91521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91522       };
91523     } catch (...) {
91524       {
91525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91526       };
91527     }
91528   }
91529 }
91530
91531
91532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
91533   void * jresult ;
91534   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
91535
91536   {
91537     try {
91538       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
91539     } catch (std::out_of_range& e) {
91540       {
91541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91542       };
91543     } catch (std::exception& e) {
91544       {
91545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91546       };
91547     } catch (...) {
91548       {
91549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91550       };
91551     }
91552   }
91553   jresult = (void *)result;
91554   return jresult;
91555 }
91556
91557
91558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
91559   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91560
91561   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91562   {
91563     try {
91564       delete arg1;
91565     } catch (std::out_of_range& e) {
91566       {
91567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91568       };
91569     } catch (std::exception& e) {
91570       {
91571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91572       };
91573     } catch (...) {
91574       {
91575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91576       };
91577     }
91578   }
91579 }
91580
91581
91582 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
91583   unsigned int jresult ;
91584   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91585   bool result;
91586
91587   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91588   {
91589     try {
91590       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
91591     } catch (std::out_of_range& e) {
91592       {
91593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91594       };
91595     } catch (std::exception& e) {
91596       {
91597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91598       };
91599     } catch (...) {
91600       {
91601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91602       };
91603     }
91604   }
91605   jresult = result;
91606   return jresult;
91607 }
91608
91609
91610 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
91611   unsigned long jresult ;
91612   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91613   std::size_t result;
91614
91615   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91616   {
91617     try {
91618       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
91619     } catch (std::out_of_range& e) {
91620       {
91621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91622       };
91623     } catch (std::exception& e) {
91624       {
91625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91626       };
91627     } catch (...) {
91628       {
91629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91630       };
91631     }
91632   }
91633   jresult = (unsigned long)result;
91634   return jresult;
91635 }
91636
91637
91638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
91639   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91640   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
91641
91642   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91643   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
91644   {
91645     try {
91646       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
91647     } catch (std::out_of_range& e) {
91648       {
91649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91650       };
91651     } catch (std::exception& e) {
91652       {
91653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91654       };
91655     } catch (...) {
91656       {
91657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91658       };
91659     }
91660   }
91661 }
91662
91663
91664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
91665   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91666   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
91667
91668   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91669   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
91670   {
91671     try {
91672       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
91673     } catch (std::out_of_range& e) {
91674       {
91675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91676       };
91677     } catch (std::exception& e) {
91678       {
91679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91680       };
91681     } catch (...) {
91682       {
91683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91684       };
91685     }
91686   }
91687 }
91688
91689
91690 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
91691   unsigned int jresult ;
91692   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91693   Dali::Toolkit::Slider arg2 ;
91694   float arg3 ;
91695   Dali::Toolkit::Slider *argp2 ;
91696   bool result;
91697
91698   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91699   argp2 = (Dali::Toolkit::Slider *)jarg2;
91700   if (!argp2) {
91701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
91702     return 0;
91703   }
91704   arg2 = *argp2;
91705   arg3 = (float)jarg3;
91706   {
91707     try {
91708       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
91709     } catch (std::out_of_range& e) {
91710       {
91711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91712       };
91713     } catch (std::exception& e) {
91714       {
91715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91716       };
91717     } catch (...) {
91718       {
91719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91720       };
91721     }
91722   }
91723   jresult = result;
91724   return jresult;
91725 }
91726
91727
91728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
91729   void * jresult ;
91730   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
91731
91732   {
91733     try {
91734       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
91735     } catch (std::out_of_range& e) {
91736       {
91737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91738       };
91739     } catch (std::exception& e) {
91740       {
91741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91742       };
91743     } catch (...) {
91744       {
91745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91746       };
91747     }
91748   }
91749   jresult = (void *)result;
91750   return jresult;
91751 }
91752
91753
91754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
91755   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91756
91757   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91758   {
91759     try {
91760       delete arg1;
91761     } catch (std::out_of_range& e) {
91762       {
91763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91764       };
91765     } catch (std::exception& e) {
91766       {
91767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91768       };
91769     } catch (...) {
91770       {
91771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91772       };
91773     }
91774   }
91775 }
91776
91777
91778 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
91779   unsigned int jresult ;
91780   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91781   bool result;
91782
91783   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91784   {
91785     try {
91786       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
91787     } catch (std::out_of_range& e) {
91788       {
91789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91790       };
91791     } catch (std::exception& e) {
91792       {
91793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91794       };
91795     } catch (...) {
91796       {
91797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91798       };
91799     }
91800   }
91801   jresult = result;
91802   return jresult;
91803 }
91804
91805
91806 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
91807   unsigned long jresult ;
91808   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91809   std::size_t result;
91810
91811   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91812   {
91813     try {
91814       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
91815     } catch (std::out_of_range& e) {
91816       {
91817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91818       };
91819     } catch (std::exception& e) {
91820       {
91821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91822       };
91823     } catch (...) {
91824       {
91825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91826       };
91827     }
91828   }
91829   jresult = (unsigned long)result;
91830   return jresult;
91831 }
91832
91833
91834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
91835   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91836   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
91837
91838   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91839   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
91840   {
91841     try {
91842       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
91843     } catch (std::out_of_range& e) {
91844       {
91845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91846       };
91847     } catch (std::exception& e) {
91848       {
91849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91850       };
91851     } catch (...) {
91852       {
91853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91854       };
91855     }
91856   }
91857 }
91858
91859
91860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
91861   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91862   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
91863
91864   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91865   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
91866   {
91867     try {
91868       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
91869     } catch (std::out_of_range& e) {
91870       {
91871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91872       };
91873     } catch (std::exception& e) {
91874       {
91875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91876       };
91877     } catch (...) {
91878       {
91879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91880       };
91881     }
91882   }
91883 }
91884
91885
91886 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
91887   unsigned int jresult ;
91888   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91889   Dali::Toolkit::Slider arg2 ;
91890   int arg3 ;
91891   Dali::Toolkit::Slider *argp2 ;
91892   bool result;
91893
91894   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91895   argp2 = (Dali::Toolkit::Slider *)jarg2;
91896   if (!argp2) {
91897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
91898     return 0;
91899   }
91900   arg2 = *argp2;
91901   arg3 = (int)jarg3;
91902   {
91903     try {
91904       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
91905     } catch (std::out_of_range& e) {
91906       {
91907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91908       };
91909     } catch (std::exception& e) {
91910       {
91911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91912       };
91913     } catch (...) {
91914       {
91915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91916       };
91917     }
91918   }
91919   jresult = result;
91920   return jresult;
91921 }
91922
91923
91924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
91925   void * jresult ;
91926   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
91927
91928   {
91929     try {
91930       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
91931     } catch (std::out_of_range& e) {
91932       {
91933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91934       };
91935     } catch (std::exception& e) {
91936       {
91937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91938       };
91939     } catch (...) {
91940       {
91941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91942       };
91943     }
91944   }
91945   jresult = (void *)result;
91946   return jresult;
91947 }
91948
91949
91950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
91951   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91952
91953   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91954   {
91955     try {
91956       delete arg1;
91957     } catch (std::out_of_range& e) {
91958       {
91959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91960       };
91961     } catch (std::exception& e) {
91962       {
91963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91964       };
91965     } catch (...) {
91966       {
91967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91968       };
91969     }
91970   }
91971 }
91972
91973
91974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
91975   void * jresult ;
91976   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91977
91978   {
91979     try {
91980       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
91981     } catch (std::out_of_range& e) {
91982       {
91983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91984       };
91985     } catch (std::exception& e) {
91986       {
91987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91988       };
91989     } catch (...) {
91990       {
91991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91992       };
91993     }
91994   }
91995   jresult = (void *)result;
91996   return jresult;
91997 }
91998
91999
92000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
92001   void * jresult ;
92002   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
92003   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92004
92005   arg1 = (Dali::Toolkit::Ruler *)jarg1;
92006   {
92007     try {
92008       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
92009     } catch (std::out_of_range& e) {
92010       {
92011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92012       };
92013     } catch (std::exception& e) {
92014       {
92015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92016       };
92017     } catch (...) {
92018       {
92019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92020       };
92021     }
92022   }
92023   jresult = (void *)result;
92024   return jresult;
92025 }
92026
92027
92028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
92029   void * jresult ;
92030   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
92031   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92032
92033   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92034   if (!arg1) {
92035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
92036     return 0;
92037   }
92038   {
92039     try {
92040       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
92041     } catch (std::out_of_range& e) {
92042       {
92043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92044       };
92045     } catch (std::exception& e) {
92046       {
92047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92048       };
92049     } catch (...) {
92050       {
92051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92052       };
92053     }
92054   }
92055   jresult = (void *)result;
92056   return jresult;
92057 }
92058
92059
92060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
92061   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92062
92063   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92064   {
92065     try {
92066       delete arg1;
92067     } catch (std::out_of_range& e) {
92068       {
92069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92070       };
92071     } catch (std::exception& e) {
92072       {
92073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92074       };
92075     } catch (...) {
92076       {
92077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92078       };
92079     }
92080   }
92081 }
92082
92083
92084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
92085   void * jresult ;
92086   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92087   Dali::Toolkit::Ruler *result = 0 ;
92088
92089   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92090   {
92091     try {
92092       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
92093     } catch (std::out_of_range& e) {
92094       {
92095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92096       };
92097     } catch (std::exception& e) {
92098       {
92099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92100       };
92101     } catch (...) {
92102       {
92103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92104       };
92105     }
92106   }
92107   jresult = (void *)result;
92108   return jresult;
92109 }
92110
92111
92112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
92113   void * jresult ;
92114   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92115   Dali::Toolkit::Ruler *result = 0 ;
92116
92117   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92118   {
92119     try {
92120       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
92121     } catch (std::out_of_range& e) {
92122       {
92123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92124       };
92125     } catch (std::exception& e) {
92126       {
92127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92128       };
92129     } catch (...) {
92130       {
92131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92132       };
92133     }
92134   }
92135   jresult = (void *)result;
92136   return jresult;
92137 }
92138
92139
92140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
92141   void * jresult ;
92142   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92143   Dali::Toolkit::Ruler *result = 0 ;
92144
92145   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92146   {
92147     try {
92148       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
92149     } catch (std::out_of_range& e) {
92150       {
92151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92152       };
92153     } catch (std::exception& e) {
92154       {
92155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92156       };
92157     } catch (...) {
92158       {
92159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92160       };
92161     }
92162   }
92163   jresult = (void *)result;
92164   return jresult;
92165 }
92166
92167
92168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
92169   void * jresult ;
92170   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92171   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
92172   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92173
92174   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92175   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
92176   if (!arg2) {
92177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
92178     return 0;
92179   }
92180   {
92181     try {
92182       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
92183     } catch (std::out_of_range& e) {
92184       {
92185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92186       };
92187     } catch (std::exception& e) {
92188       {
92189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92190       };
92191     } catch (...) {
92192       {
92193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92194       };
92195     }
92196   }
92197   jresult = (void *)result;
92198   return jresult;
92199 }
92200
92201
92202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
92203   void * jresult ;
92204   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92205   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
92206   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92207
92208   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92209   arg2 = (Dali::Toolkit::Ruler *)jarg2;
92210   {
92211     try {
92212       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
92213     } catch (std::out_of_range& e) {
92214       {
92215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92216       };
92217     } catch (std::exception& e) {
92218       {
92219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92220       };
92221     } catch (...) {
92222       {
92223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92224       };
92225     }
92226   }
92227   jresult = (void *)result;
92228   return jresult;
92229 }
92230
92231
92232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
92233   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92234
92235   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92236   {
92237     try {
92238       (arg1)->Reset();
92239     } catch (std::out_of_range& e) {
92240       {
92241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92242       };
92243     } catch (std::exception& e) {
92244       {
92245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92246       };
92247     } catch (...) {
92248       {
92249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92250       };
92251     }
92252   }
92253 }
92254
92255
92256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
92257   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92258   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
92259
92260   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92261   arg2 = (Dali::Toolkit::Ruler *)jarg2;
92262   {
92263     try {
92264       (arg1)->Reset(arg2);
92265     } catch (std::out_of_range& e) {
92266       {
92267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92268       };
92269     } catch (std::exception& e) {
92270       {
92271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92272       };
92273     } catch (...) {
92274       {
92275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92276       };
92277     }
92278   }
92279 }
92280
92281
92282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
92283   void * jresult ;
92284   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92285   Dali::Toolkit::Ruler *result = 0 ;
92286
92287   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92288   {
92289     try {
92290       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
92291     } catch (std::out_of_range& e) {
92292       {
92293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92294       };
92295     } catch (std::exception& e) {
92296       {
92297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92298       };
92299     } catch (...) {
92300       {
92301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92302       };
92303     }
92304   }
92305   jresult = (void *)result;
92306   return jresult;
92307 }
92308
92309
92310 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
92311   float jresult ;
92312   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92313   float arg2 ;
92314   float arg3 ;
92315   float result;
92316
92317   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92318   arg2 = (float)jarg2;
92319   arg3 = (float)jarg3;
92320   {
92321     try {
92322       result = (float)(*arg1)->Snap(arg2,arg3);
92323     } catch (std::out_of_range& e) {
92324       {
92325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92326       };
92327     } catch (std::exception& e) {
92328       {
92329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92330       };
92331     } catch (...) {
92332       {
92333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92334       };
92335     }
92336   }
92337   jresult = result;
92338   return jresult;
92339 }
92340
92341
92342 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
92343   float jresult ;
92344   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92345   float arg2 ;
92346   float result;
92347
92348   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92349   arg2 = (float)jarg2;
92350   {
92351     try {
92352       result = (float)(*arg1)->Snap(arg2);
92353     } catch (std::out_of_range& e) {
92354       {
92355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92356       };
92357     } catch (std::exception& e) {
92358       {
92359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92360       };
92361     } catch (...) {
92362       {
92363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92364       };
92365     }
92366   }
92367   jresult = result;
92368   return jresult;
92369 }
92370
92371
92372 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
92373   float jresult ;
92374   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92375   unsigned int arg2 ;
92376   unsigned int *arg3 = 0 ;
92377   bool arg4 ;
92378   float result;
92379
92380   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92381   arg2 = (unsigned int)jarg2;
92382   arg3 = (unsigned int *)jarg3;
92383   arg4 = jarg4 ? true : false;
92384   {
92385     try {
92386       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
92387     } catch (std::out_of_range& e) {
92388       {
92389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92390       };
92391     } catch (std::exception& e) {
92392       {
92393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92394       };
92395     } catch (...) {
92396       {
92397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92398       };
92399     }
92400   }
92401   jresult = result;
92402   return jresult;
92403 }
92404
92405
92406 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
92407   unsigned int jresult ;
92408   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92409   float arg2 ;
92410   bool arg3 ;
92411   unsigned int result;
92412
92413   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92414   arg2 = (float)jarg2;
92415   arg3 = jarg3 ? true : false;
92416   {
92417     try {
92418       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
92419     } catch (std::out_of_range& e) {
92420       {
92421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92422       };
92423     } catch (std::exception& e) {
92424       {
92425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92426       };
92427     } catch (...) {
92428       {
92429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92430       };
92431     }
92432   }
92433   jresult = result;
92434   return jresult;
92435 }
92436
92437
92438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
92439   unsigned int jresult ;
92440   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92441   unsigned int result;
92442
92443   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92444   {
92445     try {
92446       result = (unsigned int)(*arg1)->GetTotalPages();
92447     } catch (std::out_of_range& e) {
92448       {
92449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92450       };
92451     } catch (std::exception& e) {
92452       {
92453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92454       };
92455     } catch (...) {
92456       {
92457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92458       };
92459     }
92460   }
92461   jresult = result;
92462   return jresult;
92463 }
92464
92465
92466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
92467   int jresult ;
92468   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92469   Dali::Toolkit::Ruler::RulerType result;
92470
92471   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92472   {
92473     try {
92474       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
92475     } catch (std::out_of_range& e) {
92476       {
92477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92478       };
92479     } catch (std::exception& e) {
92480       {
92481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92482       };
92483     } catch (...) {
92484       {
92485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92486       };
92487     }
92488   }
92489   jresult = (int)result;
92490   return jresult;
92491 }
92492
92493
92494 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
92495   unsigned int jresult ;
92496   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92497   bool result;
92498
92499   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92500   {
92501     try {
92502       result = (bool)(*arg1)->IsEnabled();
92503     } catch (std::out_of_range& e) {
92504       {
92505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92506       };
92507     } catch (std::exception& e) {
92508       {
92509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92510       };
92511     } catch (...) {
92512       {
92513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92514       };
92515     }
92516   }
92517   jresult = result;
92518   return jresult;
92519 }
92520
92521
92522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
92523   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92524
92525   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92526   {
92527     try {
92528       (*arg1)->Enable();
92529     } catch (std::out_of_range& e) {
92530       {
92531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92532       };
92533     } catch (std::exception& e) {
92534       {
92535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92536       };
92537     } catch (...) {
92538       {
92539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92540       };
92541     }
92542   }
92543 }
92544
92545
92546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
92547   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92548
92549   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92550   {
92551     try {
92552       (*arg1)->Disable();
92553     } catch (std::out_of_range& e) {
92554       {
92555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92556       };
92557     } catch (std::exception& e) {
92558       {
92559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92560       };
92561     } catch (...) {
92562       {
92563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92564       };
92565     }
92566   }
92567 }
92568
92569
92570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
92571   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92572   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
92573   Dali::Toolkit::RulerDomain *argp2 ;
92574
92575   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92576   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
92577   if (!argp2) {
92578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
92579     return ;
92580   }
92581   arg2 = *argp2;
92582   {
92583     try {
92584       (*arg1)->SetDomain(arg2);
92585     } catch (std::out_of_range& e) {
92586       {
92587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92588       };
92589     } catch (std::exception& e) {
92590       {
92591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92592       };
92593     } catch (...) {
92594       {
92595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92596       };
92597     }
92598   }
92599 }
92600
92601
92602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
92603   void * jresult ;
92604   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92605   Dali::Toolkit::RulerDomain *result = 0 ;
92606
92607   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92608   {
92609     try {
92610       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
92611     } catch (std::out_of_range& e) {
92612       {
92613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92614       };
92615     } catch (std::exception& e) {
92616       {
92617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92618       };
92619     } catch (...) {
92620       {
92621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92622       };
92623     }
92624   }
92625   jresult = (void *)result;
92626   return jresult;
92627 }
92628
92629
92630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
92631   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92632
92633   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92634   {
92635     try {
92636       (*arg1)->DisableDomain();
92637     } catch (std::out_of_range& e) {
92638       {
92639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92640       };
92641     } catch (std::exception& e) {
92642       {
92643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92644       };
92645     } catch (...) {
92646       {
92647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92648       };
92649     }
92650   }
92651 }
92652
92653
92654 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
92655   float jresult ;
92656   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92657   float arg2 ;
92658   float arg3 ;
92659   float arg4 ;
92660   float result;
92661
92662   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92663   arg2 = (float)jarg2;
92664   arg3 = (float)jarg3;
92665   arg4 = (float)jarg4;
92666   {
92667     try {
92668       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
92669     } catch (std::out_of_range& e) {
92670       {
92671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92672       };
92673     } catch (std::exception& e) {
92674       {
92675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92676       };
92677     } catch (...) {
92678       {
92679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92680       };
92681     }
92682   }
92683   jresult = result;
92684   return jresult;
92685 }
92686
92687
92688 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
92689   float jresult ;
92690   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92691   float arg2 ;
92692   float arg3 ;
92693   float result;
92694
92695   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92696   arg2 = (float)jarg2;
92697   arg3 = (float)jarg3;
92698   {
92699     try {
92700       result = (float)(*arg1)->Clamp(arg2,arg3);
92701     } catch (std::out_of_range& e) {
92702       {
92703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92704       };
92705     } catch (std::exception& e) {
92706       {
92707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92708       };
92709     } catch (...) {
92710       {
92711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92712       };
92713     }
92714   }
92715   jresult = result;
92716   return jresult;
92717 }
92718
92719
92720 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
92721   float jresult ;
92722   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92723   float arg2 ;
92724   float result;
92725
92726   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92727   arg2 = (float)jarg2;
92728   {
92729     try {
92730       result = (float)(*arg1)->Clamp(arg2);
92731     } catch (std::out_of_range& e) {
92732       {
92733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92734       };
92735     } catch (std::exception& e) {
92736       {
92737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92738       };
92739     } catch (...) {
92740       {
92741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92742       };
92743     }
92744   }
92745   jresult = result;
92746   return jresult;
92747 }
92748
92749
92750 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
92751   float jresult ;
92752   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92753   float arg2 ;
92754   float arg3 ;
92755   float arg4 ;
92756   Dali::Toolkit::ClampState *arg5 = 0 ;
92757   float result;
92758
92759   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92760   arg2 = (float)jarg2;
92761   arg3 = (float)jarg3;
92762   arg4 = (float)jarg4;
92763   arg5 = (Dali::Toolkit::ClampState *)jarg5;
92764   if (!arg5) {
92765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
92766     return 0;
92767   }
92768   {
92769     try {
92770       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
92771     } catch (std::out_of_range& e) {
92772       {
92773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92774       };
92775     } catch (std::exception& e) {
92776       {
92777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92778       };
92779     } catch (...) {
92780       {
92781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92782       };
92783     }
92784   }
92785   jresult = result;
92786   return jresult;
92787 }
92788
92789
92790 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
92791   float jresult ;
92792   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92793   float arg2 ;
92794   float arg3 ;
92795   float arg4 ;
92796   float arg5 ;
92797   float result;
92798
92799   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92800   arg2 = (float)jarg2;
92801   arg3 = (float)jarg3;
92802   arg4 = (float)jarg4;
92803   arg5 = (float)jarg5;
92804   {
92805     try {
92806       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
92807     } catch (std::out_of_range& e) {
92808       {
92809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92810       };
92811     } catch (std::exception& e) {
92812       {
92813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92814       };
92815     } catch (...) {
92816       {
92817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92818       };
92819     }
92820   }
92821   jresult = result;
92822   return jresult;
92823 }
92824
92825
92826 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
92827   float jresult ;
92828   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92829   float arg2 ;
92830   float arg3 ;
92831   float arg4 ;
92832   float result;
92833
92834   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92835   arg2 = (float)jarg2;
92836   arg3 = (float)jarg3;
92837   arg4 = (float)jarg4;
92838   {
92839     try {
92840       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
92841     } catch (std::out_of_range& e) {
92842       {
92843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92844       };
92845     } catch (std::exception& e) {
92846       {
92847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92848       };
92849     } catch (...) {
92850       {
92851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92852       };
92853     }
92854   }
92855   jresult = result;
92856   return jresult;
92857 }
92858
92859
92860 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
92861   float jresult ;
92862   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92863   float arg2 ;
92864   float arg3 ;
92865   float result;
92866
92867   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92868   arg2 = (float)jarg2;
92869   arg3 = (float)jarg3;
92870   {
92871     try {
92872       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
92873     } catch (std::out_of_range& e) {
92874       {
92875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92876       };
92877     } catch (std::exception& e) {
92878       {
92879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92880       };
92881     } catch (...) {
92882       {
92883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92884       };
92885     }
92886   }
92887   jresult = result;
92888   return jresult;
92889 }
92890
92891
92892 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
92893   float jresult ;
92894   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92895   float arg2 ;
92896   float result;
92897
92898   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92899   arg2 = (float)jarg2;
92900   {
92901     try {
92902       result = (float)(*arg1)->SnapAndClamp(arg2);
92903     } catch (std::out_of_range& e) {
92904       {
92905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92906       };
92907     } catch (std::exception& e) {
92908       {
92909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92910       };
92911     } catch (...) {
92912       {
92913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92914       };
92915     }
92916   }
92917   jresult = result;
92918   return jresult;
92919 }
92920
92921
92922 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
92923   float jresult ;
92924   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92925   float arg2 ;
92926   float arg3 ;
92927   float arg4 ;
92928   float arg5 ;
92929   Dali::Toolkit::ClampState *arg6 = 0 ;
92930   float result;
92931
92932   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92933   arg2 = (float)jarg2;
92934   arg3 = (float)jarg3;
92935   arg4 = (float)jarg4;
92936   arg5 = (float)jarg5;
92937   arg6 = (Dali::Toolkit::ClampState *)jarg6;
92938   if (!arg6) {
92939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
92940     return 0;
92941   }
92942   {
92943     try {
92944       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
92945     } catch (std::out_of_range& e) {
92946       {
92947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92948       };
92949     } catch (std::exception& e) {
92950       {
92951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92952       };
92953     } catch (...) {
92954       {
92955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92956       };
92957     }
92958   }
92959   jresult = result;
92960   return jresult;
92961 }
92962
92963
92964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
92965   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92966
92967   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92968   {
92969     try {
92970       (*arg1)->Reference();
92971     } catch (std::out_of_range& e) {
92972       {
92973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92974       };
92975     } catch (std::exception& e) {
92976       {
92977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92978       };
92979     } catch (...) {
92980       {
92981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92982       };
92983     }
92984   }
92985 }
92986
92987
92988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
92989   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92990
92991   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92992   {
92993     try {
92994       (*arg1)->Unreference();
92995     } catch (std::out_of_range& e) {
92996       {
92997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92998       };
92999     } catch (std::exception& e) {
93000       {
93001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93002       };
93003     } catch (...) {
93004       {
93005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93006       };
93007     }
93008   }
93009 }
93010
93011
93012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
93013   int jresult ;
93014   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93015   int result;
93016
93017   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93018   {
93019     try {
93020       result = (int)(*arg1)->ReferenceCount();
93021     } catch (std::out_of_range& e) {
93022       {
93023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93024       };
93025     } catch (std::exception& e) {
93026       {
93027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93028       };
93029     } catch (...) {
93030       {
93031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93032       };
93033     }
93034   }
93035   jresult = result;
93036   return jresult;
93037 }
93038
93039
93040 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
93041     return (Dali::RefObject *)jarg1;
93042 }
93043
93044 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
93045     return (Dali::SignalObserver *)jarg1;
93046 }
93047
93048 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
93049     return (Dali::ConnectionTrackerInterface *)jarg1;
93050 }
93051
93052 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
93053     return (Dali::BaseHandle *)jarg1;
93054 }
93055
93056 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
93057     return (Dali::BaseHandle *)jarg1;
93058 }
93059
93060 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
93061     return (Dali::BaseHandle *)jarg1;
93062 }
93063
93064 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
93065     return (Dali::BaseHandle *)jarg1;
93066 }
93067
93068 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
93069     return (Dali::BaseHandle *)jarg1;
93070 }
93071
93072 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
93073     return (Dali::BaseHandle *)jarg1;
93074 }
93075
93076 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
93077     return (Dali::BaseHandle *)jarg1;
93078 }
93079
93080 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
93081     return (Dali::BaseHandle *)jarg1;
93082 }
93083
93084 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
93085     return (Dali::BaseHandle *)jarg1;
93086 }
93087
93088 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
93089     return (Dali::BaseHandle *)jarg1;
93090 }
93091
93092 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
93093     return (Dali::BaseHandle *)jarg1;
93094 }
93095
93096 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
93097     return (Dali::BaseHandle *)jarg1;
93098 }
93099
93100 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
93101     return (Dali::BaseHandle *)jarg1;
93102 }
93103
93104 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
93105     return (Dali::Handle *)jarg1;
93106 }
93107
93108 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
93109     return (Dali::Handle *)jarg1;
93110 }
93111
93112 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
93113     return (Dali::BaseHandle *)jarg1;
93114 }
93115
93116 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
93117     return (Dali::BaseHandle *)jarg1;
93118 }
93119
93120 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
93121     return (Dali::Handle *)jarg1;
93122 }
93123
93124 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
93125     return (Dali::BaseHandle *)jarg1;
93126 }
93127
93128 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
93129     return (Dali::Handle *)jarg1;
93130 }
93131
93132 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
93133     return (Dali::GestureDetector *)jarg1;
93134 }
93135
93136 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
93137     return (Dali::Gesture *)jarg1;
93138 }
93139
93140 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
93141     return (Dali::Handle *)jarg1;
93142 }
93143
93144 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
93145     return (Dali::Actor *)jarg1;
93146 }
93147
93148 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
93149     return (Dali::BaseHandle *)jarg1;
93150 }
93151
93152 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
93153     return (Dali::RefObject *)jarg1;
93154 }
93155
93156 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
93157     return (Dali::Actor *)jarg1;
93158 }
93159
93160 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
93161     return (Dali::GestureDetector *)jarg1;
93162 }
93163
93164 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
93165     return (Dali::Gesture *)jarg1;
93166 }
93167
93168 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
93169     return (Dali::GestureDetector *)jarg1;
93170 }
93171
93172 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
93173     return (Dali::Gesture *)jarg1;
93174 }
93175
93176 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
93177     return (Dali::GestureDetector *)jarg1;
93178 }
93179
93180 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
93181     return (Dali::Gesture *)jarg1;
93182 }
93183
93184 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
93185     return (Dali::BaseHandle *)jarg1;
93186 }
93187
93188 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
93189     return (Dali::Handle *)jarg1;
93190 }
93191
93192 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Animation_SWIGUpcast(Dali::Animation *jarg1) {
93193     return (Dali::BaseHandle *)jarg1;
93194 }
93195
93196 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
93197     return (Dali::Handle *)jarg1;
93198 }
93199
93200 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
93201     return (Dali::Handle *)jarg1;
93202 }
93203
93204 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
93205     return (Dali::Image *)jarg1;
93206 }
93207
93208 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
93209     return (Dali::Image *)jarg1;
93210 }
93211
93212 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
93213     return (Dali::Image *)jarg1;
93214 }
93215
93216 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
93217     return (Dali::RefObject *)jarg1;
93218 }
93219
93220 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
93221     return (Dali::Image *)jarg1;
93222 }
93223
93224 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
93225     return (Dali::Image *)jarg1;
93226 }
93227
93228 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
93229     return (Dali::ResourceImage *)jarg1;
93230 }
93231
93232 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
93233     return (Dali::Actor *)jarg1;
93234 }
93235
93236 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
93237     return (Dali::BaseHandle *)jarg1;
93238 }
93239
93240 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
93241     return (Dali::BaseHandle *)jarg1;
93242 }
93243
93244 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Window_SWIGUpcast(Dali::Window *jarg1) {
93245     return (Dali::BaseHandle *)jarg1;
93246 }
93247
93248 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Application_SWIGUpcast(Dali::Application *jarg1) {
93249     return (Dali::BaseHandle *)jarg1;
93250 }
93251
93252 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
93253     return (Dali::BaseHandle *)jarg1;
93254 }
93255
93256 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
93257     return (Dali::BaseHandle *)jarg1;
93258 }
93259
93260 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
93261     return (Dali::CustomActorImpl *)jarg1;
93262 }
93263
93264 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
93265     return (Dali::CustomActor *)jarg1;
93266 }
93267
93268 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
93269     return (Dali::BaseHandle *)jarg1;
93270 }
93271
93272 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
93273     return (Dali::Toolkit::Control *)jarg1;
93274 }
93275
93276 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
93277     return (Dali::Toolkit::Control *)jarg1;
93278 }
93279
93280 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
93281     return (Dali::Toolkit::Button *)jarg1;
93282 }
93283
93284 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
93285     return (Dali::Toolkit::Button *)jarg1;
93286 }
93287
93288 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
93289     return (Dali::Toolkit::Button *)jarg1;
93290 }
93291
93292 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
93293     return (Dali::Toolkit::Control *)jarg1;
93294 }
93295
93296 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
93297     return (Dali::Toolkit::Control *)jarg1;
93298 }
93299
93300 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
93301     return (Dali::Toolkit::Control *)jarg1;
93302 }
93303
93304 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
93305     return (Dali::Toolkit::Control *)jarg1;
93306 }
93307
93308 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
93309     return (Dali::Toolkit::Control *)jarg1;
93310 }
93311
93312 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
93313     return (Dali::RefObject *)jarg1;
93314 }
93315
93316 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
93317     return (Dali::Toolkit::Scrollable *)jarg1;
93318 }
93319
93320 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
93321     return (Dali::BaseHandle *)jarg1;
93322 }
93323
93324 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
93325     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
93326 }
93327
93328 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
93329     return (Dali::RefObject *)jarg1;
93330 }
93331
93332 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
93333     return (Dali::Toolkit::Ruler *)jarg1;
93334 }
93335
93336 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
93337     return (Dali::Toolkit::Ruler *)jarg1;
93338 }
93339
93340 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
93341     return (Dali::Toolkit::Scrollable *)jarg1;
93342 }
93343
93344 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
93345     return (Dali::Toolkit::Control *)jarg1;
93346 }
93347
93348 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextEditor_SWIGUpcast(Dali::Toolkit::TextEditor *jarg1) {
93349     return (Dali::Toolkit::Control *)jarg1;
93350 }
93351
93352 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextField_SWIGUpcast(Dali::Toolkit::TextField *jarg1) {
93353     return (Dali::Toolkit::Control *)jarg1;
93354 }
93355
93356 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
93357     return (Dali::Toolkit::Control *)jarg1;
93358 }
93359
93360 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
93361     return (Dali::BaseHandle *)jarg1;
93362 }
93363
93364 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
93365     return (Dali::BaseHandle *)jarg1;
93366 }
93367
93368 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
93369     return (Dali::Toolkit::Control *)jarg1;
93370 }
93371
93372 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
93373     return (Dali::Toolkit::Control *)jarg1;
93374 }
93375
93376 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
93377     return (Dali::Toolkit::Control *)jarg1;
93378 }
93379
93380 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
93381     return (Dali::Toolkit::Control *)jarg1;
93382 }
93383
93384 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
93385     return (Dali::Toolkit::Control *)jarg1;
93386 }
93387
93388 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
93389     return (Dali::Toolkit::Control *)jarg1;
93390 }
93391
93392 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
93393     return (Dali::Toolkit::PageTurnView *)jarg1;
93394 }
93395
93396 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
93397     return (Dali::Toolkit::PageTurnView *)jarg1;
93398 }
93399
93400 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
93401     return (Dali::Toolkit::Button *)jarg1;
93402 }
93403
93404 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
93405     return (Dali::BaseHandle *)jarg1;
93406 }
93407
93408 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
93409     return (Dali::BaseHandle *)jarg1;
93410 }
93411
93412 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
93413     return (Dali::BaseHandle *)jarg1;
93414 }
93415
93416 #ifdef __cplusplus
93417 }
93418 #endif
93419