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
 426 #include <dali/devel-api/actors/actor-devel.h>
 427
 428 #include <dali/public-api/math/matrix.h>
 429 #include <dali/public-api/math/matrix3.h>
 430 #include <dali/public-api/math/viewport.h>
 431 #include <dali/public-api/object/property-key.h>
 432 #include <dali/devel-api/object/csharp-type-info.h>
 433 #include <dali/devel-api/object/csharp-type-registry.h>
 434
 435 #include <dali/public-api/adaptor-framework/timer.h>
 436 #include <dali/public-api/adaptor-framework/window.h>
 437 #include <dali/public-api/adaptor-framework/style-change.h>
 438 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
 439 #include <dali/devel-api/adaptor-framework/application-extensions.h>
 440 #include <dali/devel-api/adaptor-framework/window-devel.h>
 441
 442 #include <dali/devel-api/images/nine-patch-image.h>
 443
 444 #include <dali-toolkit/devel-api/builder/builder.h>
 445
 446 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 447 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 448
 449 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 450 #include <dali-toolkit/devel-api/controls/progress-bar/progress-bar.h>
 451 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 455 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 456 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 457
 458 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 459 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 460 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 461
 462 #include <dali-toolkit/devel-api/visuals/text-visual-properties.h>
 463
 464 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 465
 466 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 467
 468 // add here SWIG version check
 469
 470 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 471 // disable Swig-dependent warnings
 472
 473 // 'identifier1' has C-linkage specified,
 474 // but returns UDT 'identifier2' which is incompatible with C
 475 #pragma warning(disable: 4190)
 476
 477 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 478 #pragma warning(disable: 4800)
 479
 480 // debug info too long etc etc
 481 #pragma warning(disable: 4786)
 482 #endif
 483
 484
 485 #include <stdexcept>
 486
 487
 488 #include <string>
 489
 490
 491 #include <vector>
 492 #include <algorithm>
 493 #include <stdexcept>
 494
 495
 496 #include <map>
 497 #include <algorithm>
 498 #include <stdexcept>
 499
 500
 501 #include <utility>
 502
 503
 504 typedef float floatp;
 505
 506 SWIGINTERN floatp *new_floatp(){
 507   return new float();
 508 }
 509 SWIGINTERN void delete_floatp(floatp *self){
 510   if (self) delete self;
 511 }
 512 SWIGINTERN void floatp_assign(floatp *self,float value){
 513   *self = value;
 514 }
 515 SWIGINTERN float floatp_value(floatp *self){
 516   return *self;
 517 }
 518 SWIGINTERN float *floatp_cast(floatp *self){
 519   return self;
 520 }
 521 SWIGINTERN floatp *floatp_frompointer(float *t){
 522   return (floatp *) t;
 523 }
 524
 525 typedef int intp;
 526
 527 SWIGINTERN intp *new_intp(){
 528   return new int();
 529 }
 530 SWIGINTERN void delete_intp(intp *self){
 531   if (self) delete self;
 532 }
 533 SWIGINTERN void intp_assign(intp *self,int value){
 534   *self = value;
 535 }
 536 SWIGINTERN int intp_value(intp *self){
 537   return *self;
 538 }
 539 SWIGINTERN int *intp_cast(intp *self){
 540   return self;
 541 }
 542 SWIGINTERN intp *intp_frompointer(int *t){
 543   return (intp *) t;
 544 }
 545
 546 typedef double doublep;
 547
 548 SWIGINTERN doublep *new_doublep(){
 549   return new double();
 550 }
 551 SWIGINTERN void delete_doublep(doublep *self){
 552   if (self) delete self;
 553 }
 554 SWIGINTERN void doublep_assign(doublep *self,double value){
 555   *self = value;
 556 }
 557 SWIGINTERN double doublep_value(doublep *self){
 558   return *self;
 559 }
 560 SWIGINTERN double *doublep_cast(doublep *self){
 561   return self;
 562 }
 563 SWIGINTERN doublep *doublep_frompointer(double *t){
 564   return (doublep *) t;
 565 }
 566
 567 typedef unsigned int uintp;
 568
 569 SWIGINTERN uintp *new_uintp(){
 570   return new unsigned int();
 571 }
 572 SWIGINTERN void delete_uintp(uintp *self){
 573   if (self) delete self;
 574 }
 575 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 576   *self = value;
 577 }
 578 SWIGINTERN unsigned int uintp_value(uintp *self){
 579   return *self;
 580 }
 581 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 582   return self;
 583 }
 584 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 585   return (uintp *) t;
 586 }
 587
 588 typedef unsigned short ushortp;
 589
 590 SWIGINTERN ushortp *new_ushortp(){
 591   return new unsigned short();
 592 }
 593 SWIGINTERN void delete_ushortp(ushortp *self){
 594   if (self) delete self;
 595 }
 596 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 597   *self = value;
 598 }
 599 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 600   return *self;
 601 }
 602 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 603   return self;
 604 }
 605 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 606   return (ushortp *) t;
 607 }
 608
 609 unsigned int int_to_uint(int x) {
 610    return (unsigned int) x;
 611 }
 612
 613
 614 using namespace Dali;
 615 using namespace Dali::Toolkit;
 616
 617 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self){
 618
 619      // C++ code. DALi uses Handle <-> Body design pattern.
 620      // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 621      // Handles in DALi can be converted into a boolean type
 622      // to check if the handle has a valid body attached to it.
 623      // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 624      if( *self )
 625      {
 626        return true;
 627      }
 628      else
 629      {
 630        return false;
 631      }
 632     }
 633 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs){
 634
 635      // C++ code. Check if two handles reference the same implemtion
 636      if( *self == rhs)
 637      {
 638        return true;
 639      }
 640      else
 641      {
 642        return false;
 643      }
 644     }
 645 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 646      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 647    }
 648 SWIGINTERN void Dali_TypeRegistration_RegisterProperty(std::string const &controlName,std::string const &propertyName,int index,Dali::Property::Type type,Dali::CSharpTypeInfo::SetPropertyFunction setFunc,Dali::CSharpTypeInfo::GetPropertyFunction getFunc){
 649      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 650    }
 651 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 652         std::vector< Dali::TouchPoint >* pv = 0;
 653         if (capacity >= 0) {
 654           pv = new std::vector< Dali::TouchPoint >();
 655           pv->reserve(capacity);
 656        } else {
 657           throw std::out_of_range("capacity");
 658        }
 659        return pv;
 660       }
 661 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 662         if (index>=0 && index<(int)self->size())
 663           return (*self)[index];
 664         else
 665           throw std::out_of_range("index");
 666       }
 667 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 668         if (index>=0 && index<(int)self->size())
 669           return (*self)[index];
 670         else
 671           throw std::out_of_range("index");
 672       }
 673 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 674         if (index>=0 && index<(int)self->size())
 675           (*self)[index] = val;
 676         else
 677           throw std::out_of_range("index");
 678       }
 679 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 680         self->insert(self->end(), values.begin(), values.end());
 681       }
 682 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 683         if (index < 0)
 684           throw std::out_of_range("index");
 685         if (count < 0)
 686           throw std::out_of_range("count");
 687         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 688           throw std::invalid_argument("invalid range");
 689         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 690       }
 691 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 692         if (index>=0 && index<(int)self->size()+1)
 693           self->insert(self->begin()+index, x);
 694         else
 695           throw std::out_of_range("index");
 696       }
 697 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 698         if (index>=0 && index<(int)self->size()+1)
 699           self->insert(self->begin()+index, values.begin(), values.end());
 700         else
 701           throw std::out_of_range("index");
 702       }
 703 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 704         if (index>=0 && index<(int)self->size())
 705           self->erase(self->begin() + index);
 706         else
 707           throw std::out_of_range("index");
 708       }
 709 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 710         if (index < 0)
 711           throw std::out_of_range("index");
 712         if (count < 0)
 713           throw std::out_of_range("count");
 714         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 715           throw std::invalid_argument("invalid range");
 716         self->erase(self->begin()+index, self->begin()+index+count);
 717       }
 718 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 719         if (count < 0)
 720           throw std::out_of_range("count");
 721         return new std::vector< Dali::TouchPoint >(count, value);
 722       }
 723 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 724         std::reverse(self->begin(), self->end());
 725       }
 726 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 727         if (index < 0)
 728           throw std::out_of_range("index");
 729         if (count < 0)
 730           throw std::out_of_range("count");
 731         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 732           throw std::invalid_argument("invalid range");
 733         std::reverse(self->begin()+index, self->begin()+index+count);
 734       }
 735 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 736         if (index < 0)
 737           throw std::out_of_range("index");
 738         if (index+values.size() > self->size())
 739           throw std::out_of_range("index");
 740         std::copy(values.begin(), values.end(), self->begin()+index);
 741       }
 742 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 743          return self->Empty();
 744       }
 745 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 746         return self->GetConnectionCount();
 747       }
 748 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 749           self->Connect( func );
 750       }
 751 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 752           self->Disconnect( func );
 753       }
 754 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 755           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 756 /*@SWIG@*/ self->Emit( arg );
 757       }
 758 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 759          return self->Empty();
 760       }
 761 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 762         return self->GetConnectionCount();
 763       }
 764 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 765           self->Connect( func );
 766       }
 767 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 768           self->Disconnect( func );
 769       }
 770 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 771           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 772 /*@SWIG@*/ self->Emit( arg );
 773       }
 774 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 775          return self->Empty();
 776       }
 777 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::RefObject const *) > const *self){
 778         return self->GetConnectionCount();
 779       }
 780 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 781           self->Connect( func );
 782       }
 783 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 784           self->Disconnect( func );
 785       }
 786 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::RefObject const *) > *self,Dali::RefObject const *arg){
 787           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 788 /*@SWIG@*/ self->Emit( arg );
 789       }
 790 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 791          return self->Empty();
 792       }
 793 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 794         return self->GetConnectionCount();
 795       }
 796 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 797           self->Connect( func );
 798       }
 799 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 800           self->Disconnect( func );
 801       }
 802 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 803           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 804 /*@SWIG@*/ self->Emit( arg );
 805       }
 806 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 807          return self->Empty();
 808       }
 809 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 810         return self->GetConnectionCount();
 811       }
 812 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 813           self->Connect( func );
 814       }
 815 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 816           self->Disconnect( func );
 817       }
 818 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 819           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 820 /*@SWIG@*/ self->Emit( arg );
 821       }
 822 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 823          return self->Empty();
 824       }
 825 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 826         return self->GetConnectionCount();
 827       }
 828 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 829         self->Connect( func );
 830       }
 831 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 832         self->Disconnect( func );
 833       }
 834 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,Dali::Actor arg1,Dali::LongPressGesture const &arg2){
 835         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 836 /*@SWIG@*/ self->Emit( arg1, arg2 );
 837       }
 838 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 839          return self->Empty();
 840       }
 841 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 842         return self->GetConnectionCount();
 843       }
 844 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 845         self->Connect( func );
 846       }
 847 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 848         self->Disconnect( func );
 849       }
 850 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,Dali::Actor arg1,Dali::TouchData const &arg2){
 851         return self->Emit( arg1, arg2 );
 852       }
 853 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 854          return self->Empty();
 855       }
 856 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 857         return self->GetConnectionCount();
 858       }
 859 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 860         self->Connect( func );
 861       }
 862 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 863         self->Disconnect( func );
 864       }
 865 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,Dali::Actor arg1,Dali::HoverEvent const &arg2){
 866         return self->Emit( arg1, arg2 );
 867       }
 868 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 869          return self->Empty();
 870       }
 871 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 872         return self->GetConnectionCount();
 873       }
 874 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 875         self->Connect( func );
 876       }
 877 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 878         self->Disconnect( func );
 879       }
 880 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,Dali::Actor arg1,Dali::WheelEvent const &arg2){
 881         return self->Emit( arg1, arg2 );
 882       }
 883 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 884          return self->Empty();
 885       }
 886 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 887         return self->GetConnectionCount();
 888       }
 889 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 890           self->Connect( func );
 891       }
 892 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 893           self->Disconnect( func );
 894       }
 895 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 896           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 897 /*@SWIG@*/ self->Emit( arg );
 898       }
 899 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 900          return self->Empty();
 901       }
 902 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 903         return self->GetConnectionCount();
 904       }
 905 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 906           self->Connect( func );
 907       }
 908 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 909           self->Disconnect( func );
 910       }
 911 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::KeyEvent const &) > *self,Dali::KeyEvent const &arg){
 912           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 913 /*@SWIG@*/ self->Emit( arg );
 914       }
 915 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 916          return self->Empty();
 917       }
 918 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::TouchData const &) > const *self){
 919         return self->GetConnectionCount();
 920       }
 921 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 922           self->Connect( func );
 923       }
 924 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 925           self->Disconnect( func );
 926       }
 927 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::TouchData const &) > *self,Dali::TouchData const &arg){
 928           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 929 /*@SWIG@*/ self->Emit( arg );
 930       }
 931 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 932          return self->Empty();
 933       }
 934 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 935         return self->GetConnectionCount();
 936       }
 937 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
 938           self->Connect( func );
 939       }
 940 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
 941           self->Disconnect( func );
 942       }
 943 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::WheelEvent const &) > *self,Dali::WheelEvent const &arg){
 944           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 945 /*@SWIG@*/ self->Emit( arg );
 946       }
 947 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
 948          return self->Empty();
 949       }
 950 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
 951         return self->GetConnectionCount();
 952       }
 953 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
 954         self->Connect( func );
 955       }
 956 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
 957         self->Disconnect( func );
 958       }
 959 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,Dali::Actor arg1,Dali::PanGesture const &arg2){
 960         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 961 /*@SWIG@*/ self->Emit( arg1, arg2 );
 962       }
 963 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
 964          return self->Empty();
 965       }
 966 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
 967         return self->GetConnectionCount();
 968       }
 969 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
 970         self->Connect( func );
 971       }
 972 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
 973         self->Disconnect( func );
 974       }
 975 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,Dali::Actor arg1,Dali::PinchGesture const &arg2){
 976         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 977 /*@SWIG@*/ self->Emit( arg1, arg2 );
 978       }
 979 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
 980          return self->Empty();
 981       }
 982 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
 983         return self->GetConnectionCount();
 984       }
 985 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
 986         self->Connect( func );
 987       }
 988 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
 989         self->Disconnect( func );
 990       }
 991 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,Dali::Actor arg1,Dali::TapGesture const &arg2){
 992         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 993 /*@SWIG@*/ self->Emit( arg1, arg2 );
 994       }
 995 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Animation &) > const *self){
 996          return self->Empty();
 997       }
 998 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Animation &) > const *self){
 999         return self->GetConnectionCount();
1000       }
1001 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
1002           self->Connect( func );
1003       }
1004 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
1005           self->Disconnect( func );
1006       }
1007 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Animation &) > *self,Dali::Animation &arg){
1008           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1009 /*@SWIG@*/ self->Emit( arg );
1010       }
1011 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1012          return self->Empty();
1013       }
1014 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1015         return self->GetConnectionCount();
1016       }
1017 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1018           self->Connect( func );
1019       }
1020 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1021           self->Disconnect( func );
1022       }
1023 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1024           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1025 /*@SWIG@*/ self->Emit( arg );
1026       }
1027
1028   // keep argcs and argv so they're always available to DALi
1029   int argC = 1;
1030   char **argV = NULL;
1031
1032 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Application &) > const *self){
1033          return self->Empty();
1034       }
1035 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &) > const *self){
1036         return self->GetConnectionCount();
1037       }
1038 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
1039           self->Connect( func );
1040       }
1041 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
1042           self->Disconnect( func );
1043       }
1044 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Application &) > *self,Dali::Application &arg){
1045           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1046 /*@SWIG@*/ self->Emit( arg );
1047       }
1048 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::Application &,void *) > const *self){
1049          return self->Empty();
1050       }
1051 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &,void *) > const *self){
1052         return self->GetConnectionCount();
1053       }
1054 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::Application &,void *) > *self,void (*func)(Dali::Application &,void *)){
1055         self->Connect( func );
1056       }
1057 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &,void *) > *self,void (*func)(Dali::Application &,void *)){
1058         self->Disconnect( func );
1059       }
1060 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::Application &,void *) > *self,Dali::Application &arg1,void *arg2){
1061         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1062 /*@SWIG@*/ self->Emit( arg1, arg2 );
1063       }
1064 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1065          return self->Empty();
1066       }
1067 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1068         return self->GetConnectionCount();
1069       }
1070 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1071           self->Connect( func );
1072       }
1073 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1074           self->Disconnect( func );
1075       }
1076 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1077           return self->Emit();
1078       }
1079 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1080         std::vector< unsigned int >* pv = 0;
1081         if (capacity >= 0) {
1082           pv = new std::vector< unsigned int >();
1083           pv->reserve(capacity);
1084        } else {
1085           throw std::out_of_range("capacity");
1086        }
1087        return pv;
1088       }
1089 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1090         if (index>=0 && index<(int)self->size())
1091           return (*self)[index];
1092         else
1093           throw std::out_of_range("index");
1094       }
1095 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1096         if (index>=0 && index<(int)self->size())
1097           return (*self)[index];
1098         else
1099           throw std::out_of_range("index");
1100       }
1101 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1102         if (index>=0 && index<(int)self->size())
1103           (*self)[index] = val;
1104         else
1105           throw std::out_of_range("index");
1106       }
1107 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1108         self->insert(self->end(), values.begin(), values.end());
1109       }
1110 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1111         if (index < 0)
1112           throw std::out_of_range("index");
1113         if (count < 0)
1114           throw std::out_of_range("count");
1115         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1116           throw std::invalid_argument("invalid range");
1117         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1118       }
1119 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1120         if (index>=0 && index<(int)self->size()+1)
1121           self->insert(self->begin()+index, x);
1122         else
1123           throw std::out_of_range("index");
1124       }
1125 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1126         if (index>=0 && index<(int)self->size()+1)
1127           self->insert(self->begin()+index, values.begin(), values.end());
1128         else
1129           throw std::out_of_range("index");
1130       }
1131 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1132         if (index>=0 && index<(int)self->size())
1133           self->erase(self->begin() + index);
1134         else
1135           throw std::out_of_range("index");
1136       }
1137 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1138         if (index < 0)
1139           throw std::out_of_range("index");
1140         if (count < 0)
1141           throw std::out_of_range("count");
1142         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1143           throw std::invalid_argument("invalid range");
1144         self->erase(self->begin()+index, self->begin()+index+count);
1145       }
1146 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1147         if (count < 0)
1148           throw std::out_of_range("count");
1149         return new std::vector< unsigned int >(count, value);
1150       }
1151 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1152         std::reverse(self->begin(), self->end());
1153       }
1154 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(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         std::reverse(self->begin()+index, self->begin()+index+count);
1162       }
1163 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1164         if (index < 0)
1165           throw std::out_of_range("index");
1166         if (index+values.size() > self->size())
1167           throw std::out_of_range("index");
1168         std::copy(values.begin(), values.end(), self->begin()+index);
1169       }
1170 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1171         return std::find(self->begin(), self->end(), value) != self->end();
1172       }
1173 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1174         int index = -1;
1175         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1176         if (it != self->end())
1177           index = (int)(it - self->begin());
1178         return index;
1179       }
1180 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1181         int index = -1;
1182         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1183         if (rit != self->rend())
1184           index = (int)(self->rend() - 1 - rit);
1185         return index;
1186       }
1187 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1188         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1189         if (it != self->end()) {
1190           self->erase(it);
1191           return true;
1192         }
1193         return false;
1194       }
1195 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){
1196         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1197         if (capacity >= 0) {
1198           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1199           pv->reserve(capacity);
1200        } else {
1201           throw std::out_of_range("capacity");
1202        }
1203        return pv;
1204       }
1205 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){
1206         if (index>=0 && index<(int)self->size())
1207           return (*self)[index];
1208         else
1209           throw std::out_of_range("index");
1210       }
1211 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){
1212         if (index>=0 && index<(int)self->size())
1213           return (*self)[index];
1214         else
1215           throw std::out_of_range("index");
1216       }
1217 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){
1218         if (index>=0 && index<(int)self->size())
1219           (*self)[index] = val;
1220         else
1221           throw std::out_of_range("index");
1222       }
1223 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){
1224         self->insert(self->end(), values.begin(), values.end());
1225       }
1226 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){
1227         if (index < 0)
1228           throw std::out_of_range("index");
1229         if (count < 0)
1230           throw std::out_of_range("count");
1231         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1232           throw std::invalid_argument("invalid range");
1233         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1234       }
1235 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){
1236         if (index>=0 && index<(int)self->size()+1)
1237           self->insert(self->begin()+index, x);
1238         else
1239           throw std::out_of_range("index");
1240       }
1241 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){
1242         if (index>=0 && index<(int)self->size()+1)
1243           self->insert(self->begin()+index, values.begin(), values.end());
1244         else
1245           throw std::out_of_range("index");
1246       }
1247 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){
1248         if (index>=0 && index<(int)self->size())
1249           self->erase(self->begin() + index);
1250         else
1251           throw std::out_of_range("index");
1252       }
1253 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){
1254         if (index < 0)
1255           throw std::out_of_range("index");
1256         if (count < 0)
1257           throw std::out_of_range("count");
1258         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1259           throw std::invalid_argument("invalid range");
1260         self->erase(self->begin()+index, self->begin()+index+count);
1261       }
1262 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){
1263         if (count < 0)
1264           throw std::out_of_range("count");
1265         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1266       }
1267 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){
1268         std::reverse(self->begin(), self->end());
1269       }
1270 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){
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         std::reverse(self->begin()+index, self->begin()+index+count);
1278       }
1279 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){
1280         if (index < 0)
1281           throw std::out_of_range("index");
1282         if (index+values.size() > self->size())
1283           throw std::out_of_range("index");
1284         std::copy(values.begin(), values.end(), self->begin()+index);
1285       }
1286 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1287         std::vector< Dali::Actor >* pv = 0;
1288         if (capacity >= 0) {
1289           pv = new std::vector< Dali::Actor >();
1290           pv->reserve(capacity);
1291        } else {
1292           throw std::out_of_range("capacity");
1293        }
1294        return pv;
1295       }
1296 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1297         if (index>=0 && index<(int)self->size())
1298           return (*self)[index];
1299         else
1300           throw std::out_of_range("index");
1301       }
1302 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1303         if (index>=0 && index<(int)self->size())
1304           return (*self)[index];
1305         else
1306           throw std::out_of_range("index");
1307       }
1308 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1309         if (index>=0 && index<(int)self->size())
1310           (*self)[index] = val;
1311         else
1312           throw std::out_of_range("index");
1313       }
1314 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1315         self->insert(self->end(), values.begin(), values.end());
1316       }
1317 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1318         if (index < 0)
1319           throw std::out_of_range("index");
1320         if (count < 0)
1321           throw std::out_of_range("count");
1322         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1323           throw std::invalid_argument("invalid range");
1324         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1325       }
1326 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1327         if (index>=0 && index<(int)self->size()+1)
1328           self->insert(self->begin()+index, x);
1329         else
1330           throw std::out_of_range("index");
1331       }
1332 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1333         if (index>=0 && index<(int)self->size()+1)
1334           self->insert(self->begin()+index, values.begin(), values.end());
1335         else
1336           throw std::out_of_range("index");
1337       }
1338 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1339         if (index>=0 && index<(int)self->size())
1340           self->erase(self->begin() + index);
1341         else
1342           throw std::out_of_range("index");
1343       }
1344 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1345         if (index < 0)
1346           throw std::out_of_range("index");
1347         if (count < 0)
1348           throw std::out_of_range("count");
1349         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1350           throw std::invalid_argument("invalid range");
1351         self->erase(self->begin()+index, self->begin()+index+count);
1352       }
1353 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1354         if (count < 0)
1355           throw std::out_of_range("count");
1356         return new std::vector< Dali::Actor >(count, value);
1357       }
1358 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1359         std::reverse(self->begin(), self->end());
1360       }
1361 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(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         std::reverse(self->begin()+index, self->begin()+index+count);
1369       }
1370 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1371         if (index < 0)
1372           throw std::out_of_range("index");
1373         if (index+values.size() > self->size())
1374           throw std::out_of_range("index");
1375         std::copy(values.begin(), values.end(), self->begin()+index);
1376       }
1377 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1378          return self->Empty();
1379       }
1380 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1381         return self->GetConnectionCount();
1382       }
1383 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 &)){
1384           self->Connect( func );
1385       }
1386 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 &)){
1387           self->Disconnect( func );
1388       }
1389 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){
1390           return self->Emit( arg );
1391       }
1392 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){
1393          return self->Empty();
1394       }
1395 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){
1396         return self->GetConnectionCount();
1397       }
1398 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)){
1399         self->Connect( func );
1400       }
1401 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)){
1402         self->Disconnect( func );
1403       }
1404 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){
1405         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1406 /*@SWIG@*/ self->Emit( arg1, arg2 );
1407       }
1408 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1409          return self->Empty();
1410       }
1411 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){
1412         return self->GetConnectionCount();
1413       }
1414 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)){
1415         self->Connect( func );
1416       }
1417 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)){
1418         self->Disconnect( func );
1419       }
1420 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){
1421         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1422 /*@SWIG@*/ self->Emit( arg1, arg2 );
1423       }
1424 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1425          return self->Empty();
1426       }
1427 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1428         return self->GetConnectionCount();
1429       }
1430 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)){
1431         self->Connect( func );
1432       }
1433 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)){
1434         self->Disconnect( func );
1435       }
1436 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){
1437         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1438 /*@SWIG@*/ self->Emit( arg1, arg2 );
1439       }
1440 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1441          return self->Empty();
1442       }
1443 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){
1444         return self->GetConnectionCount();
1445       }
1446 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)){
1447         self->Connect( func );
1448       }
1449 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)){
1450         self->Disconnect( func );
1451       }
1452 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){
1453         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1454 /*@SWIG@*/ self->Emit( arg1, arg2 );
1455       }
1456 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1457          return self->Empty();
1458       }
1459 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1460         return self->GetConnectionCount();
1461       }
1462 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)){
1463           self->Connect( func );
1464       }
1465 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)){
1466           self->Disconnect( func );
1467       }
1468 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1469           return self->Emit( arg );
1470       }
1471 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1472          return self->Empty();
1473       }
1474 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1475         return self->GetConnectionCount();
1476       }
1477 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)){
1478           self->Connect( func );
1479       }
1480 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)){
1481           self->Disconnect( func );
1482       }
1483 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1484           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1485 /*@SWIG@*/ self->Emit( arg );
1486       }
1487 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){
1488          return self->Empty();
1489       }
1490 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){
1491         return self->GetConnectionCount();
1492       }
1493 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)){
1494           return self->Connect( func );
1495       }
1496 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)){
1497           self->Disconnect( func );
1498       }
1499 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){
1500           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1501 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1502       }
1503 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1504          return self->Empty();
1505       }
1506 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1507         return self->GetConnectionCount();
1508       }
1509 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)){
1510           self->Connect( func );
1511       }
1512 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)){
1513           self->Disconnect( func );
1514       }
1515 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1516           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1517 /*@SWIG@*/ self->Emit( arg );
1518       }
1519 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){
1520          return self->Empty();
1521       }
1522 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){
1523         return self->GetConnectionCount();
1524       }
1525 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)){
1526           return self->Connect( func );
1527       }
1528 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)){
1529           self->Disconnect( func );
1530       }
1531 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){
1532           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1533 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1534       }
1535 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){
1536          return self->Empty();
1537       }
1538 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){
1539         return self->GetConnectionCount();
1540       }
1541 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 &)){
1542           self->Connect( func );
1543       }
1544 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 &)){
1545           self->Disconnect( func );
1546       }
1547 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){
1548           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1549 /*@SWIG@*/ self->Emit( arg );
1550       }
1551 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1552          return self->Empty();
1553       }
1554 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){
1555         return self->GetConnectionCount();
1556       }
1557 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 &)){
1558           self->Connect( func );
1559       }
1560 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 &)){
1561           self->Disconnect( func );
1562       }
1563 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){
1564           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1565 /*@SWIG@*/ self->Emit( arg );
1566       }
1567 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1568          return self->Empty();
1569       }
1570 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1571         return self->GetConnectionCount();
1572       }
1573 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)){
1574           self->Connect( func );
1575       }
1576 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)){
1577           self->Disconnect( func );
1578       }
1579 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,Dali::Toolkit::TextEditor arg){
1580           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1581 /*@SWIG@*/ self->Emit( arg );
1582       }
1583 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1584          return self->Empty();
1585       }
1586 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1587         return self->GetConnectionCount();
1588       }
1589 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)){
1590           self->Connect( func );
1591       }
1592 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)){
1593           self->Disconnect( func );
1594       }
1595 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextField) > *self,Dali::Toolkit::TextField arg){
1596           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1597 /*@SWIG@*/ self->Emit( arg );
1598       }
1599 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){
1600          return self->Empty();
1601       }
1602 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){
1603         return self->GetConnectionCount();
1604       }
1605 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 &)){
1606         self->Connect( func );
1607       }
1608 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 &)){
1609         self->Disconnect( func );
1610       }
1611 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){
1612         return self->Emit( arg1, arg2 );
1613       }
1614 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1615          return self->Empty();
1616       }
1617 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1618         return self->GetConnectionCount();
1619       }
1620 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)){
1621           self->Connect( func );
1622       }
1623 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)){
1624           self->Disconnect( func );
1625       }
1626 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1627           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1628 /*@SWIG@*/ self->Emit( arg );
1629       }
1630 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1631          return self->Empty();
1632       }
1633 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1634         return self->GetConnectionCount();
1635       }
1636 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 &)){
1637           self->Connect( func );
1638       }
1639 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 &)){
1640           self->Disconnect( func );
1641       }
1642 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){
1643           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1644 /*@SWIG@*/ self->Emit( arg );
1645       }
1646 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1647          return self->Empty();
1648       }
1649 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){
1650         return self->GetConnectionCount();
1651       }
1652 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)){
1653         self->Connect( func );
1654       }
1655 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)){
1656         self->Disconnect( func );
1657       }
1658 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){
1659         return self->Emit( arg1, arg2 );
1660       }
1661 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1662          return self->Empty();
1663       }
1664 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){
1665         return self->GetConnectionCount();
1666       }
1667 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)){
1668         self->Connect( func );
1669       }
1670 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)){
1671         self->Disconnect( func );
1672       }
1673 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){
1674         return self->Emit( arg1, arg2 );
1675       }
1676
1677
1678 //manual merge 2017-03-31
1679 SWIGINTERN bool Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty(Dali::Signal< void (bool) > const *self){
1680          return self->Empty();
1681       }
1682 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (bool) > const *self){
1683         return self->GetConnectionCount();
1684       }
1685 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(Dali::Signal< void (bool) > *self,void (*func)(bool)){
1686           self->Connect( func );
1687       }
1688 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(Dali::Signal< void (bool) > *self,void (*func)(bool)){
1689           self->Disconnect( func );
1690       }
1691 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(Dali::Signal< void (bool) > *self,bool arg){
1692           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1693 /*@SWIG@*/ self->Emit( arg );
1694       }
1695
1696
1697
1698 /* ---------------------------------------------------
1699  * C++ director class methods
1700  * --------------------------------------------------- */
1701
1702 #include "dali_wrap.h"
1703
1704 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1705   swig_init_callbacks();
1706 }
1707
1708 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1709
1710 }
1711
1712
1713 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1714   int jdepth  ;
1715
1716   if (!swig_callbackOnStageConnection) {
1717     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1718     return;
1719   } else {
1720     jdepth = depth;
1721     swig_callbackOnStageConnection(jdepth);
1722   }
1723 }
1724
1725 void SwigDirector_ViewImpl::OnStageDisconnection() {
1726   if (!swig_callbackOnStageDisconnection) {
1727     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1728     return;
1729   } else {
1730     swig_callbackOnStageDisconnection();
1731   }
1732 }
1733
1734 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1735   void * jchild = 0 ;
1736
1737   if (!swig_callbackOnChildAdd) {
1738     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1739     return;
1740   } else {
1741     jchild = (Dali::Actor *) &child;
1742     swig_callbackOnChildAdd(jchild);
1743   }
1744 }
1745
1746 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1747   void * jchild = 0 ;
1748
1749   if (!swig_callbackOnChildRemove) {
1750     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1751     return;
1752   } else {
1753     jchild = (Dali::Actor *) &child;
1754     swig_callbackOnChildRemove(jchild);
1755   }
1756 }
1757
1758 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1759   int jindex  ;
1760   void * jpropertyValue  ;
1761
1762   if (!swig_callbackOnPropertySet) {
1763     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1764     return;
1765   } else {
1766     jindex = index;
1767     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1768     swig_callbackOnPropertySet(jindex, jpropertyValue);
1769   }
1770 }
1771
1772 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1773   void * jtargetSize = 0 ;
1774
1775   if (!swig_callbackOnSizeSet) {
1776     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1777     return;
1778   } else {
1779     jtargetSize = (Dali::Vector3 *) &targetSize;
1780     swig_callbackOnSizeSet(jtargetSize);
1781   }
1782 }
1783
1784 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1785   void * janimation = 0 ;
1786   void * jtargetSize = 0 ;
1787
1788   if (!swig_callbackOnSizeAnimation) {
1789     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1790     return;
1791   } else {
1792     janimation = (Dali::Animation *) &animation;
1793     jtargetSize = (Dali::Vector3 *) &targetSize;
1794     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1795   }
1796 }
1797
1798 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1799   bool c_result = SwigValueInit< bool >() ;
1800   unsigned int jresult = 0 ;
1801   void * jarg0 = 0 ;
1802
1803   if (!swig_callbackOnTouchEvent) {
1804     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1805   } else {
1806     jarg0 = (Dali::TouchEvent *) &event;
1807     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1808     c_result = jresult ? true : false;
1809   }
1810   return c_result;
1811 }
1812
1813 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1814   bool c_result = SwigValueInit< bool >() ;
1815   unsigned int jresult = 0 ;
1816   void * jarg0 = 0 ;
1817
1818   if (!swig_callbackOnHoverEvent) {
1819     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1820   } else {
1821     jarg0 = (Dali::HoverEvent *) &event;
1822     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1823     c_result = jresult ? true : false;
1824   }
1825   return c_result;
1826 }
1827
1828 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1829   bool c_result = SwigValueInit< bool >() ;
1830   unsigned int jresult = 0 ;
1831   void * jarg0 = 0 ;
1832
1833   if (!swig_callbackOnKeyEvent) {
1834     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1835   } else {
1836     jarg0 = (Dali::KeyEvent *) &event;
1837     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1838     c_result = jresult ? true : false;
1839   }
1840   return c_result;
1841 }
1842
1843 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1844   bool c_result = SwigValueInit< bool >() ;
1845   unsigned int jresult = 0 ;
1846   void * jarg0 = 0 ;
1847
1848   if (!swig_callbackOnWheelEvent) {
1849     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1850   } else {
1851     jarg0 = (Dali::WheelEvent *) &event;
1852     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1853     c_result = jresult ? true : false;
1854   }
1855   return c_result;
1856 }
1857
1858 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1859   void * jsize = 0 ;
1860   void * jcontainer = 0 ;
1861
1862   if (!swig_callbackOnRelayout) {
1863     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1864     return;
1865   } else {
1866     jsize = (Dali::Vector2 *) &size;
1867     jcontainer = (Dali::RelayoutContainer *) &container;
1868     swig_callbackOnRelayout(jsize, jcontainer);
1869   }
1870 }
1871
1872 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1873   int jpolicy  ;
1874   int jdimension  ;
1875
1876   if (!swig_callbackOnSetResizePolicy) {
1877     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1878     return;
1879   } else {
1880     jpolicy = (int)policy;
1881     jdimension = (int)dimension;
1882     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1883   }
1884 }
1885
1886 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1887   Dali::Vector3 c_result ;
1888   void * jresult = 0 ;
1889
1890   if (!swig_callbackGetNaturalSize) {
1891     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1892   } else {
1893     jresult = (void *) swig_callbackGetNaturalSize();
1894     if (!jresult) {
1895       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1896       return c_result;
1897     }
1898     c_result = *(Dali::Vector3 *)jresult;
1899   }
1900   return c_result;
1901 }
1902
1903 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1904   float c_result = SwigValueInit< float >() ;
1905   float jresult = 0 ;
1906   void * jchild = 0 ;
1907   int jdimension  ;
1908
1909   if (!swig_callbackCalculateChildSize) {
1910     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1911   } else {
1912     jchild = (Dali::Actor *) &child;
1913     jdimension = (int)dimension;
1914     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1915     c_result = (float)jresult;
1916   }
1917   return c_result;
1918 }
1919
1920 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
1921   float c_result = SwigValueInit< float >() ;
1922   float jresult = 0 ;
1923   float jwidth  ;
1924
1925   if (!swig_callbackGetHeightForWidth) {
1926     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
1927   } else {
1928     jwidth = width;
1929     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
1930     c_result = (float)jresult;
1931   }
1932   return c_result;
1933 }
1934
1935 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
1936   float c_result = SwigValueInit< float >() ;
1937   float jresult = 0 ;
1938   float jheight  ;
1939
1940   if (!swig_callbackGetWidthForHeight) {
1941     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
1942   } else {
1943     jheight = height;
1944     jresult = (float) swig_callbackGetWidthForHeight(jheight);
1945     c_result = (float)jresult;
1946   }
1947   return c_result;
1948 }
1949
1950 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
1951   bool c_result = SwigValueInit< bool >() ;
1952   unsigned int jresult = 0 ;
1953   int jdimension  ;
1954
1955   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
1956     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
1957   } else {
1958     jdimension = (int)dimension;
1959     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
1960     c_result = jresult ? true : false;
1961   }
1962   return c_result;
1963 }
1964
1965 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
1966   int jdimension  ;
1967
1968   if (!swig_callbackOnCalculateRelayoutSize) {
1969     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
1970     return;
1971   } else {
1972     jdimension = (int)dimension;
1973     swig_callbackOnCalculateRelayoutSize(jdimension);
1974   }
1975 }
1976
1977 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
1978   float jsize  ;
1979   int jdimension  ;
1980
1981   if (!swig_callbackOnLayoutNegotiated) {
1982     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
1983     return;
1984   } else {
1985     jsize = size;
1986     jdimension = (int)dimension;
1987     swig_callbackOnLayoutNegotiated(jsize, jdimension);
1988   }
1989 }
1990
1991 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
1992   return Dali::CustomActorImpl::GetExtension();
1993 }
1994
1995 void SwigDirector_ViewImpl::OnInitialize() {
1996   if (!swig_callbackOnInitialize) {
1997     Dali::Toolkit::Internal::Control::OnInitialize();
1998     return;
1999   } else {
2000     swig_callbackOnInitialize();
2001   }
2002 }
2003
2004 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2005   void * jchild = 0 ;
2006
2007   if (!swig_callbackOnControlChildAdd) {
2008     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2009     return;
2010   } else {
2011     jchild = (Dali::Actor *) &child;
2012     swig_callbackOnControlChildAdd(jchild);
2013   }
2014 }
2015
2016 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2017   void * jchild = 0 ;
2018
2019   if (!swig_callbackOnControlChildRemove) {
2020     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2021     return;
2022   } else {
2023     jchild = (Dali::Actor *) &child;
2024     swig_callbackOnControlChildRemove(jchild);
2025   }
2026 }
2027
2028 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2029   void * jstyleManager  ;
2030   int jchange  ;
2031
2032   if (!swig_callbackOnStyleChange) {
2033     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2034     return;
2035   } else {
2036     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2037     jchange = (int)change;
2038     swig_callbackOnStyleChange(jstyleManager, jchange);
2039   }
2040 }
2041
2042 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2043   bool c_result = SwigValueInit< bool >() ;
2044   unsigned int jresult = 0 ;
2045
2046   if (!swig_callbackOnAccessibilityActivated) {
2047     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2048   } else {
2049     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2050     c_result = jresult ? true : false;
2051   }
2052   return c_result;
2053 }
2054
2055 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2056   bool c_result = SwigValueInit< bool >() ;
2057   unsigned int jresult = 0 ;
2058   void * jgesture  ;
2059
2060   if (!swig_callbackOnAccessibilityPan) {
2061     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2062   } else {
2063     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2064     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2065     c_result = jresult ? true : false;
2066   }
2067   return c_result;
2068 }
2069
2070 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2071   bool c_result = SwigValueInit< bool >() ;
2072   unsigned int jresult = 0 ;
2073   void * jtouchEvent = 0 ;
2074
2075   if (!swig_callbackOnAccessibilityTouch) {
2076     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2077   } else {
2078     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2079     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2080     c_result = jresult ? true : false;
2081   }
2082   return c_result;
2083 }
2084
2085 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2086   bool c_result = SwigValueInit< bool >() ;
2087   unsigned int jresult = 0 ;
2088   unsigned int jisIncrease  ;
2089
2090   if (!swig_callbackOnAccessibilityValueChange) {
2091     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2092   } else {
2093     jisIncrease = isIncrease;
2094     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2095     c_result = jresult ? true : false;
2096   }
2097   return c_result;
2098 }
2099
2100 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2101   bool c_result = SwigValueInit< bool >() ;
2102   unsigned int jresult = 0 ;
2103
2104   if (!swig_callbackOnAccessibilityZoom) {
2105     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2106   } else {
2107     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2108     c_result = jresult ? true : false;
2109   }
2110   return c_result;
2111 }
2112
2113 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2114   if (!swig_callbackOnKeyInputFocusGained) {
2115     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2116     return;
2117   } else {
2118     swig_callbackOnKeyInputFocusGained();
2119   }
2120 }
2121
2122 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2123   if (!swig_callbackOnKeyInputFocusLost) {
2124     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2125     return;
2126   } else {
2127     swig_callbackOnKeyInputFocusLost();
2128   }
2129 }
2130
2131 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2132   Dali::Actor c_result ;
2133   void * jresult = 0 ;
2134   void * jcurrentFocusedActor  ;
2135   int jdirection  ;
2136   unsigned int jloopEnabled  ;
2137
2138   if (!swig_callbackGetNextKeyboardFocusableActor) {
2139     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2140   } else {
2141     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2142     jdirection = (int)direction;
2143     jloopEnabled = loopEnabled;
2144     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2145     if (!jresult) {
2146       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2147       return c_result;
2148     }
2149     c_result = *(Dali::Actor *)jresult;
2150   }
2151   return c_result;
2152 }
2153
2154 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2155   void * jcommitedFocusableActor  ;
2156
2157   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2158     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2159     return;
2160   } else {
2161     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2162     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2163   }
2164 }
2165
2166 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2167   bool c_result = SwigValueInit< bool >() ;
2168   unsigned int jresult = 0 ;
2169
2170   if (!swig_callbackOnKeyboardEnter) {
2171     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2172   } else {
2173     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2174     c_result = jresult ? true : false;
2175   }
2176   return c_result;
2177 }
2178
2179 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2180   void * jpinch = 0 ;
2181
2182   if (!swig_callbackOnPinch) {
2183     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2184     return;
2185   } else {
2186     jpinch = (Dali::PinchGesture *) &pinch;
2187     swig_callbackOnPinch(jpinch);
2188   }
2189 }
2190
2191 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2192   void * jpan = 0 ;
2193
2194   if (!swig_callbackOnPan) {
2195     Dali::Toolkit::Internal::Control::OnPan(pan);
2196     return;
2197   } else {
2198     jpan = (Dali::PanGesture *) &pan;
2199     swig_callbackOnPan(jpan);
2200   }
2201 }
2202
2203 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2204   void * jtap = 0 ;
2205
2206   if (!swig_callbackOnTap) {
2207     Dali::Toolkit::Internal::Control::OnTap(tap);
2208     return;
2209   } else {
2210     jtap = (Dali::TapGesture *) &tap;
2211     swig_callbackOnTap(jtap);
2212   }
2213 }
2214
2215 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2216   void * jlongPress = 0 ;
2217
2218   if (!swig_callbackOnLongPress) {
2219     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2220     return;
2221   } else {
2222     jlongPress = (Dali::LongPressGesture *) &longPress;
2223     swig_callbackOnLongPress(jlongPress);
2224   }
2225 }
2226
2227 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2228   void * jslotObserver = 0 ;
2229   void * jcallback = 0 ;
2230
2231   if (!swig_callbackSignalConnected) {
2232     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2233     return;
2234   } else {
2235     jslotObserver = (void *) slotObserver;
2236     jcallback = (void *) callback;
2237     swig_callbackSignalConnected(jslotObserver, jcallback);
2238   }
2239 }
2240
2241 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2242   void * jslotObserver = 0 ;
2243   void * jcallback = 0 ;
2244
2245   if (!swig_callbackSignalDisconnected) {
2246     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2247     return;
2248   } else {
2249     jslotObserver = (void *) slotObserver;
2250     jcallback = (void *) callback;
2251     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2252   }
2253 }
2254
2255 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2256   return Dali::Toolkit::Internal::Control::GetControlExtension();
2257 }
2258
2259 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) {
2260   swig_callbackOnStageConnection = callbackOnStageConnection;
2261   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2262   swig_callbackOnChildAdd = callbackOnChildAdd;
2263   swig_callbackOnChildRemove = callbackOnChildRemove;
2264   swig_callbackOnPropertySet = callbackOnPropertySet;
2265   swig_callbackOnSizeSet = callbackOnSizeSet;
2266   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2267   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2268   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2269   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2270   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2271   swig_callbackOnRelayout = callbackOnRelayout;
2272   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2273   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2274   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2275   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2276   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2277   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2278   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2279   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2280   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2281   swig_callbackOnInitialize = callbackOnInitialize;
2282   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2283   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2284   swig_callbackOnStyleChange = callbackOnStyleChange;
2285   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2286   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2287   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2288   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2289   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2290   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2291   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2292   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2293   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2294   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2295   swig_callbackOnPinch = callbackOnPinch;
2296   swig_callbackOnPan = callbackOnPan;
2297   swig_callbackOnTap = callbackOnTap;
2298   swig_callbackOnLongPress = callbackOnLongPress;
2299   swig_callbackSignalConnected = callbackSignalConnected;
2300   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2301 }
2302
2303 void SwigDirector_ViewImpl::swig_init_callbacks() {
2304   swig_callbackOnStageConnection = 0;
2305   swig_callbackOnStageDisconnection = 0;
2306   swig_callbackOnChildAdd = 0;
2307   swig_callbackOnChildRemove = 0;
2308   swig_callbackOnPropertySet = 0;
2309   swig_callbackOnSizeSet = 0;
2310   swig_callbackOnSizeAnimation = 0;
2311   swig_callbackOnTouchEvent = 0;
2312   swig_callbackOnHoverEvent = 0;
2313   swig_callbackOnKeyEvent = 0;
2314   swig_callbackOnWheelEvent = 0;
2315   swig_callbackOnRelayout = 0;
2316   swig_callbackOnSetResizePolicy = 0;
2317   swig_callbackGetNaturalSize = 0;
2318   swig_callbackCalculateChildSize = 0;
2319   swig_callbackGetHeightForWidth = 0;
2320   swig_callbackGetWidthForHeight = 0;
2321   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2322   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2323   swig_callbackOnCalculateRelayoutSize = 0;
2324   swig_callbackOnLayoutNegotiated = 0;
2325   swig_callbackOnInitialize = 0;
2326   swig_callbackOnControlChildAdd = 0;
2327   swig_callbackOnControlChildRemove = 0;
2328   swig_callbackOnStyleChange = 0;
2329   swig_callbackOnAccessibilityActivated = 0;
2330   swig_callbackOnAccessibilityPan = 0;
2331   swig_callbackOnAccessibilityTouch = 0;
2332   swig_callbackOnAccessibilityValueChange = 0;
2333   swig_callbackOnAccessibilityZoom = 0;
2334   swig_callbackOnKeyInputFocusGained = 0;
2335   swig_callbackOnKeyInputFocusLost = 0;
2336   swig_callbackGetNextKeyboardFocusableActor = 0;
2337   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2338   swig_callbackOnKeyboardEnter = 0;
2339   swig_callbackOnPinch = 0;
2340   swig_callbackOnPan = 0;
2341   swig_callbackOnTap = 0;
2342   swig_callbackOnLongPress = 0;
2343   swig_callbackSignalConnected = 0;
2344   swig_callbackSignalDisconnected = 0;
2345 }
2346
2347 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2348   swig_init_callbacks();
2349 }
2350
2351 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2352
2353 }
2354
2355
2356 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2357   unsigned int c_result = SwigValueInit< unsigned int >() ;
2358   unsigned int jresult = 0 ;
2359
2360   if (!swig_callbackGetNumberOfItems) {
2361     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2362   } else {
2363     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2364     c_result = (unsigned int)jresult;
2365   }
2366   return c_result;
2367 }
2368
2369 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2370   Dali::Actor c_result ;
2371   void * jresult = 0 ;
2372   unsigned int jitemId  ;
2373
2374   if (!swig_callbackNewItem) {
2375     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2376   } else {
2377     jitemId = itemId;
2378     jresult = (void *) swig_callbackNewItem(jitemId);
2379     if (!jresult) {
2380       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2381       return c_result;
2382     }
2383     c_result = *(Dali::Actor *)jresult;
2384   }
2385   return c_result;
2386 }
2387
2388 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2389   unsigned int jitemId  ;
2390   void * jactor  ;
2391
2392   if (!swig_callbackItemReleased) {
2393     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2394     return;
2395   } else {
2396     jitemId = itemId;
2397     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2398     swig_callbackItemReleased(jitemId, jactor);
2399   }
2400 }
2401
2402 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2403   return Dali::Toolkit::ItemFactory::GetExtension();
2404 }
2405
2406 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2407   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2408   swig_callbackNewItem = callbackNewItem;
2409   swig_callbackItemReleased = callbackItemReleased;
2410 }
2411
2412 void SwigDirector_ItemFactory::swig_init_callbacks() {
2413   swig_callbackGetNumberOfItems = 0;
2414   swig_callbackNewItem = 0;
2415   swig_callbackItemReleased = 0;
2416 }
2417
2418 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2419   swig_init_callbacks();
2420 }
2421
2422 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2423
2424 }
2425
2426
2427 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2428   Dali::Actor c_result ;
2429   void * jresult = 0 ;
2430   void * jcurrent  ;
2431   void * jproposed  ;
2432   int jdirection  ;
2433
2434   if (!swig_callbackGetNextFocusableActor) {
2435     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2436   } else {
2437     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2438     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2439     jdirection = (int)direction;
2440     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2441     if (!jresult) {
2442       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2443       return c_result;
2444     }
2445     c_result = *(Dali::Actor *)jresult;
2446   }
2447   return c_result;
2448 }
2449
2450 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2451   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2452 }
2453
2454 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2455   swig_callbackGetNextFocusableActor = 0;
2456 }
2457
2458
2459 #ifdef __cplusplus
2460 extern "C" {
2461 #endif
2462
2463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2464   void * jresult ;
2465   floatp *result = 0 ;
2466
2467   {
2468     try {
2469       result = (floatp *)new_floatp();
2470     } catch (std::out_of_range& e) {
2471       {
2472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2473       };
2474     } catch (std::exception& e) {
2475       {
2476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2477       };
2478     } catch (...) {
2479       {
2480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2481       };
2482     }
2483   }
2484   jresult = (void *)result;
2485   return jresult;
2486 }
2487
2488
2489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2490   floatp *arg1 = (floatp *) 0 ;
2491
2492   arg1 = (floatp *)jarg1;
2493   {
2494     try {
2495       delete_floatp(arg1);
2496     } catch (std::out_of_range& e) {
2497       {
2498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2499       };
2500     } catch (std::exception& e) {
2501       {
2502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2503       };
2504     } catch (...) {
2505       {
2506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2507       };
2508     }
2509   }
2510 }
2511
2512
2513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2514   floatp *arg1 = (floatp *) 0 ;
2515   float arg2 ;
2516
2517   arg1 = (floatp *)jarg1;
2518   arg2 = (float)jarg2;
2519   {
2520     try {
2521       floatp_assign(arg1,arg2);
2522     } catch (std::out_of_range& e) {
2523       {
2524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2525       };
2526     } catch (std::exception& e) {
2527       {
2528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2529       };
2530     } catch (...) {
2531       {
2532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2533       };
2534     }
2535   }
2536 }
2537
2538
2539 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2540   float jresult ;
2541   floatp *arg1 = (floatp *) 0 ;
2542   float result;
2543
2544   arg1 = (floatp *)jarg1;
2545   {
2546     try {
2547       result = (float)floatp_value(arg1);
2548     } catch (std::out_of_range& e) {
2549       {
2550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2551       };
2552     } catch (std::exception& e) {
2553       {
2554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2555       };
2556     } catch (...) {
2557       {
2558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2559       };
2560     }
2561   }
2562   jresult = result;
2563   return jresult;
2564 }
2565
2566
2567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2568   void * jresult ;
2569   floatp *arg1 = (floatp *) 0 ;
2570   float *result = 0 ;
2571
2572   arg1 = (floatp *)jarg1;
2573   {
2574     try {
2575       result = (float *)floatp_cast(arg1);
2576     } catch (std::out_of_range& e) {
2577       {
2578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2579       };
2580     } catch (std::exception& e) {
2581       {
2582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2583       };
2584     } catch (...) {
2585       {
2586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2587       };
2588     }
2589   }
2590   jresult = (void *)result;
2591   return jresult;
2592 }
2593
2594
2595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2596   void * jresult ;
2597   float *arg1 = (float *) 0 ;
2598   floatp *result = 0 ;
2599
2600   arg1 = (float *)jarg1;
2601   {
2602     try {
2603       result = (floatp *)floatp_frompointer(arg1);
2604     } catch (std::out_of_range& e) {
2605       {
2606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2607       };
2608     } catch (std::exception& e) {
2609       {
2610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2611       };
2612     } catch (...) {
2613       {
2614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2615       };
2616     }
2617   }
2618   jresult = (void *)result;
2619   return jresult;
2620 }
2621
2622
2623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2624   void * jresult ;
2625   intp *result = 0 ;
2626
2627   {
2628     try {
2629       result = (intp *)new_intp();
2630     } catch (std::out_of_range& e) {
2631       {
2632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2633       };
2634     } catch (std::exception& e) {
2635       {
2636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2637       };
2638     } catch (...) {
2639       {
2640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2641       };
2642     }
2643   }
2644   jresult = (void *)result;
2645   return jresult;
2646 }
2647
2648
2649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2650   intp *arg1 = (intp *) 0 ;
2651
2652   arg1 = (intp *)jarg1;
2653   {
2654     try {
2655       delete_intp(arg1);
2656     } catch (std::out_of_range& e) {
2657       {
2658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2659       };
2660     } catch (std::exception& e) {
2661       {
2662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2663       };
2664     } catch (...) {
2665       {
2666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2667       };
2668     }
2669   }
2670 }
2671
2672
2673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2674   intp *arg1 = (intp *) 0 ;
2675   int arg2 ;
2676
2677   arg1 = (intp *)jarg1;
2678   arg2 = (int)jarg2;
2679   {
2680     try {
2681       intp_assign(arg1,arg2);
2682     } catch (std::out_of_range& e) {
2683       {
2684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2685       };
2686     } catch (std::exception& e) {
2687       {
2688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2689       };
2690     } catch (...) {
2691       {
2692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2693       };
2694     }
2695   }
2696 }
2697
2698
2699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2700   int jresult ;
2701   intp *arg1 = (intp *) 0 ;
2702   int result;
2703
2704   arg1 = (intp *)jarg1;
2705   {
2706     try {
2707       result = (int)intp_value(arg1);
2708     } catch (std::out_of_range& e) {
2709       {
2710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2711       };
2712     } catch (std::exception& e) {
2713       {
2714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2715       };
2716     } catch (...) {
2717       {
2718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2719       };
2720     }
2721   }
2722   jresult = result;
2723   return jresult;
2724 }
2725
2726
2727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2728   void * jresult ;
2729   intp *arg1 = (intp *) 0 ;
2730   int *result = 0 ;
2731
2732   arg1 = (intp *)jarg1;
2733   {
2734     try {
2735       result = (int *)intp_cast(arg1);
2736     } catch (std::out_of_range& e) {
2737       {
2738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2739       };
2740     } catch (std::exception& e) {
2741       {
2742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2743       };
2744     } catch (...) {
2745       {
2746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2747       };
2748     }
2749   }
2750   jresult = (void *)result;
2751   return jresult;
2752 }
2753
2754
2755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2756   void * jresult ;
2757   int *arg1 = (int *) 0 ;
2758   intp *result = 0 ;
2759
2760   arg1 = (int *)jarg1;
2761   {
2762     try {
2763       result = (intp *)intp_frompointer(arg1);
2764     } catch (std::out_of_range& e) {
2765       {
2766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2767       };
2768     } catch (std::exception& e) {
2769       {
2770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2771       };
2772     } catch (...) {
2773       {
2774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2775       };
2776     }
2777   }
2778   jresult = (void *)result;
2779   return jresult;
2780 }
2781
2782
2783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2784   void * jresult ;
2785   doublep *result = 0 ;
2786
2787   {
2788     try {
2789       result = (doublep *)new_doublep();
2790     } catch (std::out_of_range& e) {
2791       {
2792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2793       };
2794     } catch (std::exception& e) {
2795       {
2796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2797       };
2798     } catch (...) {
2799       {
2800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2801       };
2802     }
2803   }
2804   jresult = (void *)result;
2805   return jresult;
2806 }
2807
2808
2809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2810   doublep *arg1 = (doublep *) 0 ;
2811
2812   arg1 = (doublep *)jarg1;
2813   {
2814     try {
2815       delete_doublep(arg1);
2816     } catch (std::out_of_range& e) {
2817       {
2818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2819       };
2820     } catch (std::exception& e) {
2821       {
2822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2823       };
2824     } catch (...) {
2825       {
2826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2827       };
2828     }
2829   }
2830 }
2831
2832
2833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2834   doublep *arg1 = (doublep *) 0 ;
2835   double arg2 ;
2836
2837   arg1 = (doublep *)jarg1;
2838   arg2 = (double)jarg2;
2839   {
2840     try {
2841       doublep_assign(arg1,arg2);
2842     } catch (std::out_of_range& e) {
2843       {
2844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2845       };
2846     } catch (std::exception& e) {
2847       {
2848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2849       };
2850     } catch (...) {
2851       {
2852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2853       };
2854     }
2855   }
2856 }
2857
2858
2859 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2860   double jresult ;
2861   doublep *arg1 = (doublep *) 0 ;
2862   double result;
2863
2864   arg1 = (doublep *)jarg1;
2865   {
2866     try {
2867       result = (double)doublep_value(arg1);
2868     } catch (std::out_of_range& e) {
2869       {
2870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2871       };
2872     } catch (std::exception& e) {
2873       {
2874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2875       };
2876     } catch (...) {
2877       {
2878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2879       };
2880     }
2881   }
2882   jresult = result;
2883   return jresult;
2884 }
2885
2886
2887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2888   void * jresult ;
2889   doublep *arg1 = (doublep *) 0 ;
2890   double *result = 0 ;
2891
2892   arg1 = (doublep *)jarg1;
2893   {
2894     try {
2895       result = (double *)doublep_cast(arg1);
2896     } catch (std::out_of_range& e) {
2897       {
2898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2899       };
2900     } catch (std::exception& e) {
2901       {
2902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2903       };
2904     } catch (...) {
2905       {
2906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2907       };
2908     }
2909   }
2910   jresult = (void *)result;
2911   return jresult;
2912 }
2913
2914
2915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2916   void * jresult ;
2917   double *arg1 = (double *) 0 ;
2918   doublep *result = 0 ;
2919
2920   arg1 = (double *)jarg1;
2921   {
2922     try {
2923       result = (doublep *)doublep_frompointer(arg1);
2924     } catch (std::out_of_range& e) {
2925       {
2926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2927       };
2928     } catch (std::exception& e) {
2929       {
2930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2931       };
2932     } catch (...) {
2933       {
2934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2935       };
2936     }
2937   }
2938   jresult = (void *)result;
2939   return jresult;
2940 }
2941
2942
2943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
2944   void * jresult ;
2945   uintp *result = 0 ;
2946
2947   {
2948     try {
2949       result = (uintp *)new_uintp();
2950     } catch (std::out_of_range& e) {
2951       {
2952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2953       };
2954     } catch (std::exception& e) {
2955       {
2956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2957       };
2958     } catch (...) {
2959       {
2960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2961       };
2962     }
2963   }
2964   jresult = (void *)result;
2965   return jresult;
2966 }
2967
2968
2969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
2970   uintp *arg1 = (uintp *) 0 ;
2971
2972   arg1 = (uintp *)jarg1;
2973   {
2974     try {
2975       delete_uintp(arg1);
2976     } catch (std::out_of_range& e) {
2977       {
2978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2979       };
2980     } catch (std::exception& e) {
2981       {
2982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2983       };
2984     } catch (...) {
2985       {
2986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2987       };
2988     }
2989   }
2990 }
2991
2992
2993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
2994   uintp *arg1 = (uintp *) 0 ;
2995   unsigned int arg2 ;
2996
2997   arg1 = (uintp *)jarg1;
2998   arg2 = (unsigned int)jarg2;
2999   {
3000     try {
3001       uintp_assign(arg1,arg2);
3002     } catch (std::out_of_range& e) {
3003       {
3004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3005       };
3006     } catch (std::exception& e) {
3007       {
3008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3009       };
3010     } catch (...) {
3011       {
3012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3013       };
3014     }
3015   }
3016 }
3017
3018
3019 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3020   unsigned int jresult ;
3021   uintp *arg1 = (uintp *) 0 ;
3022   unsigned int result;
3023
3024   arg1 = (uintp *)jarg1;
3025   {
3026     try {
3027       result = (unsigned int)uintp_value(arg1);
3028     } catch (std::out_of_range& e) {
3029       {
3030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3031       };
3032     } catch (std::exception& e) {
3033       {
3034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3035       };
3036     } catch (...) {
3037       {
3038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3039       };
3040     }
3041   }
3042   jresult = result;
3043   return jresult;
3044 }
3045
3046
3047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3048   void * jresult ;
3049   uintp *arg1 = (uintp *) 0 ;
3050   unsigned int *result = 0 ;
3051
3052   arg1 = (uintp *)jarg1;
3053   {
3054     try {
3055       result = (unsigned int *)uintp_cast(arg1);
3056     } catch (std::out_of_range& e) {
3057       {
3058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3059       };
3060     } catch (std::exception& e) {
3061       {
3062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3063       };
3064     } catch (...) {
3065       {
3066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3067       };
3068     }
3069   }
3070   jresult = (void *)result;
3071   return jresult;
3072 }
3073
3074
3075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3076   void * jresult ;
3077   unsigned int *arg1 = (unsigned int *) 0 ;
3078   uintp *result = 0 ;
3079
3080   arg1 = (unsigned int *)jarg1;
3081   {
3082     try {
3083       result = (uintp *)uintp_frompointer(arg1);
3084     } catch (std::out_of_range& e) {
3085       {
3086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3087       };
3088     } catch (std::exception& e) {
3089       {
3090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3091       };
3092     } catch (...) {
3093       {
3094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3095       };
3096     }
3097   }
3098   jresult = (void *)result;
3099   return jresult;
3100 }
3101
3102
3103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3104   void * jresult ;
3105   ushortp *result = 0 ;
3106
3107   {
3108     try {
3109       result = (ushortp *)new_ushortp();
3110     } catch (std::out_of_range& e) {
3111       {
3112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3113       };
3114     } catch (std::exception& e) {
3115       {
3116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3117       };
3118     } catch (...) {
3119       {
3120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3121       };
3122     }
3123   }
3124   jresult = (void *)result;
3125   return jresult;
3126 }
3127
3128
3129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3130   ushortp *arg1 = (ushortp *) 0 ;
3131
3132   arg1 = (ushortp *)jarg1;
3133   {
3134     try {
3135       delete_ushortp(arg1);
3136     } catch (std::out_of_range& e) {
3137       {
3138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3139       };
3140     } catch (std::exception& e) {
3141       {
3142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3143       };
3144     } catch (...) {
3145       {
3146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3147       };
3148     }
3149   }
3150 }
3151
3152
3153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3154   ushortp *arg1 = (ushortp *) 0 ;
3155   unsigned short arg2 ;
3156
3157   arg1 = (ushortp *)jarg1;
3158   arg2 = (unsigned short)jarg2;
3159   {
3160     try {
3161       ushortp_assign(arg1,arg2);
3162     } catch (std::out_of_range& e) {
3163       {
3164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3165       };
3166     } catch (std::exception& e) {
3167       {
3168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3169       };
3170     } catch (...) {
3171       {
3172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3173       };
3174     }
3175   }
3176 }
3177
3178
3179 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3180   unsigned short jresult ;
3181   ushortp *arg1 = (ushortp *) 0 ;
3182   unsigned short result;
3183
3184   arg1 = (ushortp *)jarg1;
3185   {
3186     try {
3187       result = (unsigned short)ushortp_value(arg1);
3188     } catch (std::out_of_range& e) {
3189       {
3190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3191       };
3192     } catch (std::exception& e) {
3193       {
3194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3195       };
3196     } catch (...) {
3197       {
3198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3199       };
3200     }
3201   }
3202   jresult = result;
3203   return jresult;
3204 }
3205
3206
3207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3208   void * jresult ;
3209   ushortp *arg1 = (ushortp *) 0 ;
3210   unsigned short *result = 0 ;
3211
3212   arg1 = (ushortp *)jarg1;
3213   {
3214     try {
3215       result = (unsigned short *)ushortp_cast(arg1);
3216     } catch (std::out_of_range& e) {
3217       {
3218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3219       };
3220     } catch (std::exception& e) {
3221       {
3222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3223       };
3224     } catch (...) {
3225       {
3226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3227       };
3228     }
3229   }
3230   jresult = (void *)result;
3231   return jresult;
3232 }
3233
3234
3235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3236   void * jresult ;
3237   unsigned short *arg1 = (unsigned short *) 0 ;
3238   ushortp *result = 0 ;
3239
3240   arg1 = (unsigned short *)jarg1;
3241   {
3242     try {
3243       result = (ushortp *)ushortp_frompointer(arg1);
3244     } catch (std::out_of_range& e) {
3245       {
3246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3247       };
3248     } catch (std::exception& e) {
3249       {
3250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3251       };
3252     } catch (...) {
3253       {
3254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3255       };
3256     }
3257   }
3258   jresult = (void *)result;
3259   return jresult;
3260 }
3261
3262
3263 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3264   unsigned int jresult ;
3265   int arg1 ;
3266   unsigned int result;
3267
3268   arg1 = (int)jarg1;
3269   {
3270     try {
3271       result = (unsigned int)int_to_uint(arg1);
3272     } catch (std::out_of_range& e) {
3273       {
3274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3275       };
3276     } catch (std::exception& e) {
3277       {
3278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3279       };
3280     } catch (...) {
3281       {
3282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3283       };
3284     }
3285   }
3286   jresult = result;
3287   return jresult;
3288 }
3289
3290
3291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3292   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3293
3294   arg1 = (Dali::RefObject *)jarg1;
3295   {
3296     try {
3297       (arg1)->Reference();
3298     } catch (std::out_of_range& e) {
3299       {
3300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3301       };
3302     } catch (std::exception& e) {
3303       {
3304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3305       };
3306     } catch (...) {
3307       {
3308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3309       };
3310     }
3311   }
3312 }
3313
3314
3315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3316   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3317
3318   arg1 = (Dali::RefObject *)jarg1;
3319   {
3320     try {
3321       (arg1)->Unreference();
3322     } catch (std::out_of_range& e) {
3323       {
3324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3325       };
3326     } catch (std::exception& e) {
3327       {
3328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3329       };
3330     } catch (...) {
3331       {
3332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3333       };
3334     }
3335   }
3336 }
3337
3338
3339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3340   int jresult ;
3341   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3342   int result;
3343
3344   arg1 = (Dali::RefObject *)jarg1;
3345   {
3346     try {
3347       result = (int)(arg1)->ReferenceCount();
3348     } catch (std::out_of_range& e) {
3349       {
3350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3351       };
3352     } catch (std::exception& e) {
3353       {
3354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3355       };
3356     } catch (...) {
3357       {
3358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3359       };
3360     }
3361   }
3362   jresult = result;
3363   return jresult;
3364 }
3365
3366
3367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3368   void * jresult ;
3369   Dali::Any *result = 0 ;
3370
3371   {
3372     try {
3373       result = (Dali::Any *)new Dali::Any();
3374     } catch (std::out_of_range& e) {
3375       {
3376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3377       };
3378     } catch (std::exception& e) {
3379       {
3380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3381       };
3382     } catch (...) {
3383       {
3384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3385       };
3386     }
3387   }
3388   jresult = (void *)result;
3389   return jresult;
3390 }
3391
3392
3393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3394   Dali::Any *arg1 = (Dali::Any *) 0 ;
3395
3396   arg1 = (Dali::Any *)jarg1;
3397   {
3398     try {
3399       delete arg1;
3400     } catch (std::out_of_range& e) {
3401       {
3402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3403       };
3404     } catch (std::exception& e) {
3405       {
3406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3407       };
3408     } catch (...) {
3409       {
3410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3411       };
3412     }
3413   }
3414 }
3415
3416
3417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3418   char *arg1 = (char *) 0 ;
3419
3420   arg1 = (char *)jarg1;
3421   {
3422     try {
3423       Dali::Any::AssertAlways((char const *)arg1);
3424     } catch (std::out_of_range& e) {
3425       {
3426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3427       };
3428     } catch (std::exception& e) {
3429       {
3430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3431       };
3432     } catch (...) {
3433       {
3434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3435       };
3436     }
3437   }
3438 }
3439
3440
3441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3442   void * jresult ;
3443   Dali::Any *arg1 = 0 ;
3444   Dali::Any *result = 0 ;
3445
3446   arg1 = (Dali::Any *)jarg1;
3447   if (!arg1) {
3448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3449     return 0;
3450   }
3451   {
3452     try {
3453       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3454     } catch (std::out_of_range& e) {
3455       {
3456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3457       };
3458     } catch (std::exception& e) {
3459       {
3460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3461       };
3462     } catch (...) {
3463       {
3464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3465       };
3466     }
3467   }
3468   jresult = (void *)result;
3469   return jresult;
3470 }
3471
3472
3473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3474   void * jresult ;
3475   Dali::Any *arg1 = (Dali::Any *) 0 ;
3476   Dali::Any *arg2 = 0 ;
3477   Dali::Any *result = 0 ;
3478
3479   arg1 = (Dali::Any *)jarg1;
3480   arg2 = (Dali::Any *)jarg2;
3481   if (!arg2) {
3482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3483     return 0;
3484   }
3485   {
3486     try {
3487       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3488     } catch (std::out_of_range& e) {
3489       {
3490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3491       };
3492     } catch (std::exception& e) {
3493       {
3494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3495       };
3496     } catch (...) {
3497       {
3498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3499       };
3500     }
3501   }
3502   jresult = (void *)result;
3503   return jresult;
3504 }
3505
3506
3507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3508   void * jresult ;
3509   Dali::Any *arg1 = (Dali::Any *) 0 ;
3510   std::type_info *result = 0 ;
3511
3512   arg1 = (Dali::Any *)jarg1;
3513   {
3514     try {
3515       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3516     } catch (std::out_of_range& e) {
3517       {
3518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3519       };
3520     } catch (std::exception& e) {
3521       {
3522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3523       };
3524     } catch (...) {
3525       {
3526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3527       };
3528     }
3529   }
3530   jresult = (void *)result;
3531   return jresult;
3532 }
3533
3534
3535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3536   unsigned int jresult ;
3537   Dali::Any *arg1 = (Dali::Any *) 0 ;
3538   bool result;
3539
3540   arg1 = (Dali::Any *)jarg1;
3541   {
3542     try {
3543       result = (bool)((Dali::Any const *)arg1)->Empty();
3544     } catch (std::out_of_range& e) {
3545       {
3546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3547       };
3548     } catch (std::exception& e) {
3549       {
3550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3551       };
3552     } catch (...) {
3553       {
3554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3555       };
3556     }
3557   }
3558   jresult = result;
3559   return jresult;
3560 }
3561
3562
3563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3564   void * jresult ;
3565   std::type_info *arg1 = 0 ;
3566   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3567   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3568   Dali::Any::AnyContainerBase *result = 0 ;
3569
3570   arg1 = (std::type_info *)jarg1;
3571   if (!arg1) {
3572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3573     return 0;
3574   }
3575   arg2 = (Dali::Any::CloneFunc)jarg2;
3576   arg3 = (Dali::Any::DeleteFunc)jarg3;
3577   {
3578     try {
3579       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3580     } catch (std::out_of_range& e) {
3581       {
3582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3583       };
3584     } catch (std::exception& e) {
3585       {
3586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3587       };
3588     } catch (...) {
3589       {
3590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3591       };
3592     }
3593   }
3594   jresult = (void *)result;
3595   return jresult;
3596 }
3597
3598
3599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3600   void * jresult ;
3601   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3602   std::type_info *result = 0 ;
3603
3604   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3605   {
3606     try {
3607       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3608     } catch (std::out_of_range& e) {
3609       {
3610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3611       };
3612     } catch (std::exception& e) {
3613       {
3614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3615       };
3616     } catch (...) {
3617       {
3618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3619       };
3620     }
3621   }
3622   jresult = (void *)result;
3623   return jresult;
3624 }
3625
3626
3627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3628   void * jresult ;
3629   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3630   ::std::type_info *result = 0 ;
3631
3632   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3633   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3634   jresult = (void *)result;
3635   return jresult;
3636 }
3637
3638
3639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3640   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3641   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3642
3643   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3644   arg2 = (Dali::Any::CloneFunc)jarg2;
3645   if (arg1) (arg1)->mCloneFunc = arg2;
3646 }
3647
3648
3649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3650   void * jresult ;
3651   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3652   Dali::Any::CloneFunc result;
3653
3654   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3655   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3656   jresult = (void *)result;
3657   return jresult;
3658 }
3659
3660
3661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3662   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3663   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3664
3665   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3666   arg2 = (Dali::Any::DeleteFunc)jarg2;
3667   if (arg1) (arg1)->mDeleteFunc = arg2;
3668 }
3669
3670
3671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3672   void * jresult ;
3673   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3674   Dali::Any::DeleteFunc result;
3675
3676   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3677   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3678   jresult = (void *)result;
3679   return jresult;
3680 }
3681
3682
3683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3684   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3685
3686   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3687   {
3688     try {
3689       delete arg1;
3690     } catch (std::out_of_range& e) {
3691       {
3692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3693       };
3694     } catch (std::exception& e) {
3695       {
3696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3697       };
3698     } catch (...) {
3699       {
3700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3701       };
3702     }
3703   }
3704 }
3705
3706
3707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
3708   Dali::Any *arg1 = (Dali::Any *) 0 ;
3709   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
3710
3711   arg1 = (Dali::Any *)jarg1;
3712   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
3713   if (arg1) (arg1)->mContainer = arg2;
3714 }
3715
3716
3717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
3718   void * jresult ;
3719   Dali::Any *arg1 = (Dali::Any *) 0 ;
3720   Dali::Any::AnyContainerBase *result = 0 ;
3721
3722   arg1 = (Dali::Any *)jarg1;
3723   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
3724   jresult = (void *)result;
3725   return jresult;
3726 }
3727
3728
3729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
3730   char *arg1 = (char *) 0 ;
3731   char *arg2 = (char *) 0 ;
3732
3733   arg1 = (char *)jarg1;
3734   arg2 = (char *)jarg2;
3735   {
3736     try {
3737       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
3738     } catch (std::out_of_range& e) {
3739       {
3740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3741       };
3742     } catch (std::exception& e) {
3743       {
3744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3745       };
3746     } catch (...) {
3747       {
3748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3749       };
3750     }
3751   }
3752 }
3753
3754
3755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
3756   void * jresult ;
3757   char *arg1 = (char *) 0 ;
3758   char *arg2 = (char *) 0 ;
3759   Dali::DaliException *result = 0 ;
3760
3761   arg1 = (char *)jarg1;
3762   arg2 = (char *)jarg2;
3763   {
3764     try {
3765       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
3766     } catch (std::out_of_range& e) {
3767       {
3768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3769       };
3770     } catch (std::exception& e) {
3771       {
3772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3773       };
3774     } catch (...) {
3775       {
3776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3777       };
3778     }
3779   }
3780   jresult = (void *)result;
3781   return jresult;
3782 }
3783
3784
3785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
3786   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3787   char *arg2 = (char *) 0 ;
3788
3789   arg1 = (Dali::DaliException *)jarg1;
3790   arg2 = (char *)jarg2;
3791   {
3792     if (arg2) {
3793       arg1->location = (char const *) (new char[strlen((const char *)arg2)+1]);
3794       strcpy((char *)arg1->location, (const char *)arg2);
3795     } else {
3796       arg1->location = 0;
3797     }
3798   }
3799 }
3800
3801
3802 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
3803   char * jresult ;
3804   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3805   char *result = 0 ;
3806
3807   arg1 = (Dali::DaliException *)jarg1;
3808   result = (char *) ((arg1)->location);
3809   jresult = SWIG_csharp_string_callback((const char *)result);
3810   return jresult;
3811 }
3812
3813
3814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
3815   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3816   char *arg2 = (char *) 0 ;
3817
3818   arg1 = (Dali::DaliException *)jarg1;
3819   arg2 = (char *)jarg2;
3820   {
3821     if (arg2) {
3822       arg1->condition = (char const *) (new char[strlen((const char *)arg2)+1]);
3823       strcpy((char *)arg1->condition, (const char *)arg2);
3824     } else {
3825       arg1->condition = 0;
3826     }
3827   }
3828 }
3829
3830
3831 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
3832   char * jresult ;
3833   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3834   char *result = 0 ;
3835
3836   arg1 = (Dali::DaliException *)jarg1;
3837   result = (char *) ((arg1)->condition);
3838   jresult = SWIG_csharp_string_callback((const char *)result);
3839   return jresult;
3840 }
3841
3842
3843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
3844   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3845
3846   arg1 = (Dali::DaliException *)jarg1;
3847   {
3848     try {
3849       delete arg1;
3850     } catch (std::out_of_range& e) {
3851       {
3852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3853       };
3854     } catch (std::exception& e) {
3855       {
3856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3857       };
3858     } catch (...) {
3859       {
3860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3861       };
3862     }
3863   }
3864 }
3865
3866
3867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
3868   void * jresult ;
3869   Dali::Vector2 *result = 0 ;
3870
3871   {
3872     try {
3873       result = (Dali::Vector2 *)new Dali::Vector2();
3874     } catch (std::out_of_range& e) {
3875       {
3876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3877       };
3878     } catch (std::exception& e) {
3879       {
3880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3881       };
3882     } catch (...) {
3883       {
3884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3885       };
3886     }
3887   }
3888   jresult = (void *)result;
3889   return jresult;
3890 }
3891
3892
3893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
3894   void * jresult ;
3895   float arg1 ;
3896   float arg2 ;
3897   Dali::Vector2 *result = 0 ;
3898
3899   arg1 = (float)jarg1;
3900   arg2 = (float)jarg2;
3901   {
3902     try {
3903       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
3904     } catch (std::out_of_range& e) {
3905       {
3906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3907       };
3908     } catch (std::exception& e) {
3909       {
3910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3911       };
3912     } catch (...) {
3913       {
3914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3915       };
3916     }
3917   }
3918   jresult = (void *)result;
3919   return jresult;
3920 }
3921
3922
3923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
3924   void * jresult ;
3925   float *arg1 = (float *) 0 ;
3926   Dali::Vector2 *result = 0 ;
3927
3928   arg1 = jarg1;
3929   {
3930     try {
3931       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
3932     } catch (std::out_of_range& e) {
3933       {
3934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3935       };
3936     } catch (std::exception& e) {
3937       {
3938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3939       };
3940     } catch (...) {
3941       {
3942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3943       };
3944     }
3945   }
3946   jresult = (void *)result;
3947
3948
3949   return jresult;
3950 }
3951
3952
3953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
3954   void * jresult ;
3955   Dali::Vector3 *arg1 = 0 ;
3956   Dali::Vector2 *result = 0 ;
3957
3958   arg1 = (Dali::Vector3 *)jarg1;
3959   if (!arg1) {
3960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3961     return 0;
3962   }
3963   {
3964     try {
3965       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
3966     } catch (std::out_of_range& e) {
3967       {
3968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3969       };
3970     } catch (std::exception& e) {
3971       {
3972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3973       };
3974     } catch (...) {
3975       {
3976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3977       };
3978     }
3979   }
3980   jresult = (void *)result;
3981   return jresult;
3982 }
3983
3984
3985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
3986   void * jresult ;
3987   Dali::Vector4 *arg1 = 0 ;
3988   Dali::Vector2 *result = 0 ;
3989
3990   arg1 = (Dali::Vector4 *)jarg1;
3991   if (!arg1) {
3992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3993     return 0;
3994   }
3995   {
3996     try {
3997       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
3998     } catch (std::out_of_range& e) {
3999       {
4000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4001       };
4002     } catch (std::exception& e) {
4003       {
4004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4005       };
4006     } catch (...) {
4007       {
4008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4009       };
4010     }
4011   }
4012   jresult = (void *)result;
4013   return jresult;
4014 }
4015
4016
4017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4018   void * jresult ;
4019   Dali::Vector2 *result = 0 ;
4020
4021   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4022   jresult = (void *)result;
4023   return jresult;
4024 }
4025
4026
4027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4028   void * jresult ;
4029   Dali::Vector2 *result = 0 ;
4030
4031   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4032   jresult = (void *)result;
4033   return jresult;
4034 }
4035
4036
4037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4038   void * jresult ;
4039   Dali::Vector2 *result = 0 ;
4040
4041   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4042   jresult = (void *)result;
4043   return jresult;
4044 }
4045
4046
4047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4048   void * jresult ;
4049   Dali::Vector2 *result = 0 ;
4050
4051   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4052   jresult = (void *)result;
4053   return jresult;
4054 }
4055
4056
4057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4058   void * jresult ;
4059   Dali::Vector2 *result = 0 ;
4060
4061   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4062   jresult = (void *)result;
4063   return jresult;
4064 }
4065
4066
4067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4068   void * jresult ;
4069   Dali::Vector2 *result = 0 ;
4070
4071   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4072   jresult = (void *)result;
4073   return jresult;
4074 }
4075
4076
4077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4078   void * jresult ;
4079   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4080   float *arg2 = (float *) 0 ;
4081   Dali::Vector2 *result = 0 ;
4082
4083   arg1 = (Dali::Vector2 *)jarg1;
4084   arg2 = jarg2;
4085   {
4086     try {
4087       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4088     } catch (std::out_of_range& e) {
4089       {
4090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4091       };
4092     } catch (std::exception& e) {
4093       {
4094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4095       };
4096     } catch (...) {
4097       {
4098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4099       };
4100     }
4101   }
4102   jresult = (void *)result;
4103
4104
4105   return jresult;
4106 }
4107
4108
4109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4110   void * jresult ;
4111   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4112   Dali::Vector3 *arg2 = 0 ;
4113   Dali::Vector2 *result = 0 ;
4114
4115   arg1 = (Dali::Vector2 *)jarg1;
4116   arg2 = (Dali::Vector3 *)jarg2;
4117   if (!arg2) {
4118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4119     return 0;
4120   }
4121   {
4122     try {
4123       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4124     } catch (std::out_of_range& e) {
4125       {
4126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4127       };
4128     } catch (std::exception& e) {
4129       {
4130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4131       };
4132     } catch (...) {
4133       {
4134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4135       };
4136     }
4137   }
4138   jresult = (void *)result;
4139   return jresult;
4140 }
4141
4142
4143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4144   void * jresult ;
4145   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4146   Dali::Vector4 *arg2 = 0 ;
4147   Dali::Vector2 *result = 0 ;
4148
4149   arg1 = (Dali::Vector2 *)jarg1;
4150   arg2 = (Dali::Vector4 *)jarg2;
4151   if (!arg2) {
4152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4153     return 0;
4154   }
4155   {
4156     try {
4157       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4158     } catch (std::out_of_range& e) {
4159       {
4160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4161       };
4162     } catch (std::exception& e) {
4163       {
4164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4165       };
4166     } catch (...) {
4167       {
4168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4169       };
4170     }
4171   }
4172   jresult = (void *)result;
4173   return jresult;
4174 }
4175
4176
4177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4178   void * jresult ;
4179   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4180   Dali::Vector2 *arg2 = 0 ;
4181   Dali::Vector2 result;
4182
4183   arg1 = (Dali::Vector2 *)jarg1;
4184   arg2 = (Dali::Vector2 *)jarg2;
4185   if (!arg2) {
4186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4187     return 0;
4188   }
4189   {
4190     try {
4191       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4192     } catch (std::out_of_range& e) {
4193       {
4194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4195       };
4196     } catch (std::exception& e) {
4197       {
4198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4199       };
4200     } catch (...) {
4201       {
4202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4203       };
4204     }
4205   }
4206   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4207   return jresult;
4208 }
4209
4210
4211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4212   void * jresult ;
4213   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4214   Dali::Vector2 *arg2 = 0 ;
4215   Dali::Vector2 *result = 0 ;
4216
4217   arg1 = (Dali::Vector2 *)jarg1;
4218   arg2 = (Dali::Vector2 *)jarg2;
4219   if (!arg2) {
4220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4221     return 0;
4222   }
4223   {
4224     try {
4225       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4226     } catch (std::out_of_range& e) {
4227       {
4228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4229       };
4230     } catch (std::exception& e) {
4231       {
4232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4233       };
4234     } catch (...) {
4235       {
4236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4237       };
4238     }
4239   }
4240   jresult = (void *)result;
4241   return jresult;
4242 }
4243
4244
4245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4246   void * jresult ;
4247   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4248   Dali::Vector2 *arg2 = 0 ;
4249   Dali::Vector2 result;
4250
4251   arg1 = (Dali::Vector2 *)jarg1;
4252   arg2 = (Dali::Vector2 *)jarg2;
4253   if (!arg2) {
4254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4255     return 0;
4256   }
4257   {
4258     try {
4259       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4260     } catch (std::out_of_range& e) {
4261       {
4262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4263       };
4264     } catch (std::exception& e) {
4265       {
4266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4267       };
4268     } catch (...) {
4269       {
4270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4271       };
4272     }
4273   }
4274   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4275   return jresult;
4276 }
4277
4278
4279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4280   void * jresult ;
4281   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4282   Dali::Vector2 *arg2 = 0 ;
4283   Dali::Vector2 *result = 0 ;
4284
4285   arg1 = (Dali::Vector2 *)jarg1;
4286   arg2 = (Dali::Vector2 *)jarg2;
4287   if (!arg2) {
4288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4289     return 0;
4290   }
4291   {
4292     try {
4293       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4294     } catch (std::out_of_range& e) {
4295       {
4296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4297       };
4298     } catch (std::exception& e) {
4299       {
4300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4301       };
4302     } catch (...) {
4303       {
4304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4305       };
4306     }
4307   }
4308   jresult = (void *)result;
4309   return jresult;
4310 }
4311
4312
4313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4314   void * jresult ;
4315   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4316   Dali::Vector2 *arg2 = 0 ;
4317   Dali::Vector2 result;
4318
4319   arg1 = (Dali::Vector2 *)jarg1;
4320   arg2 = (Dali::Vector2 *)jarg2;
4321   if (!arg2) {
4322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4323     return 0;
4324   }
4325   {
4326     try {
4327       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4328     } catch (std::out_of_range& e) {
4329       {
4330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4331       };
4332     } catch (std::exception& e) {
4333       {
4334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4335       };
4336     } catch (...) {
4337       {
4338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4339       };
4340     }
4341   }
4342   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4343   return jresult;
4344 }
4345
4346
4347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4348   void * jresult ;
4349   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4350   float arg2 ;
4351   Dali::Vector2 result;
4352
4353   arg1 = (Dali::Vector2 *)jarg1;
4354   arg2 = (float)jarg2;
4355   {
4356     try {
4357       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4358     } catch (std::out_of_range& e) {
4359       {
4360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4361       };
4362     } catch (std::exception& e) {
4363       {
4364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4365       };
4366     } catch (...) {
4367       {
4368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4369       };
4370     }
4371   }
4372   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4373   return jresult;
4374 }
4375
4376
4377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4378   void * jresult ;
4379   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4380   Dali::Vector2 *arg2 = 0 ;
4381   Dali::Vector2 *result = 0 ;
4382
4383   arg1 = (Dali::Vector2 *)jarg1;
4384   arg2 = (Dali::Vector2 *)jarg2;
4385   if (!arg2) {
4386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4387     return 0;
4388   }
4389   {
4390     try {
4391       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4392     } catch (std::out_of_range& e) {
4393       {
4394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4395       };
4396     } catch (std::exception& e) {
4397       {
4398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4399       };
4400     } catch (...) {
4401       {
4402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4403       };
4404     }
4405   }
4406   jresult = (void *)result;
4407   return jresult;
4408 }
4409
4410
4411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4412   void * jresult ;
4413   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4414   float arg2 ;
4415   Dali::Vector2 *result = 0 ;
4416
4417   arg1 = (Dali::Vector2 *)jarg1;
4418   arg2 = (float)jarg2;
4419   {
4420     try {
4421       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4422     } catch (std::out_of_range& e) {
4423       {
4424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4425       };
4426     } catch (std::exception& e) {
4427       {
4428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4429       };
4430     } catch (...) {
4431       {
4432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4433       };
4434     }
4435   }
4436   jresult = (void *)result;
4437   return jresult;
4438 }
4439
4440
4441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4442   void * jresult ;
4443   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4444   Dali::Vector2 *arg2 = 0 ;
4445   Dali::Vector2 result;
4446
4447   arg1 = (Dali::Vector2 *)jarg1;
4448   arg2 = (Dali::Vector2 *)jarg2;
4449   if (!arg2) {
4450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4451     return 0;
4452   }
4453   {
4454     try {
4455       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4456     } catch (std::out_of_range& e) {
4457       {
4458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4459       };
4460     } catch (std::exception& e) {
4461       {
4462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4463       };
4464     } catch (...) {
4465       {
4466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4467       };
4468     }
4469   }
4470   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4471   return jresult;
4472 }
4473
4474
4475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4476   void * jresult ;
4477   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4478   float arg2 ;
4479   Dali::Vector2 result;
4480
4481   arg1 = (Dali::Vector2 *)jarg1;
4482   arg2 = (float)jarg2;
4483   {
4484     try {
4485       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4486     } catch (std::out_of_range& e) {
4487       {
4488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4489       };
4490     } catch (std::exception& e) {
4491       {
4492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4493       };
4494     } catch (...) {
4495       {
4496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4497       };
4498     }
4499   }
4500   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4501   return jresult;
4502 }
4503
4504
4505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4506   void * jresult ;
4507   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4508   Dali::Vector2 *arg2 = 0 ;
4509   Dali::Vector2 *result = 0 ;
4510
4511   arg1 = (Dali::Vector2 *)jarg1;
4512   arg2 = (Dali::Vector2 *)jarg2;
4513   if (!arg2) {
4514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4515     return 0;
4516   }
4517   {
4518     try {
4519       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4520     } catch (std::out_of_range& e) {
4521       {
4522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4523       };
4524     } catch (std::exception& e) {
4525       {
4526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4527       };
4528     } catch (...) {
4529       {
4530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4531       };
4532     }
4533   }
4534   jresult = (void *)result;
4535   return jresult;
4536 }
4537
4538
4539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4540   void * jresult ;
4541   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4542   float arg2 ;
4543   Dali::Vector2 *result = 0 ;
4544
4545   arg1 = (Dali::Vector2 *)jarg1;
4546   arg2 = (float)jarg2;
4547   {
4548     try {
4549       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4550     } catch (std::out_of_range& e) {
4551       {
4552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4553       };
4554     } catch (std::exception& e) {
4555       {
4556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4557       };
4558     } catch (...) {
4559       {
4560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4561       };
4562     }
4563   }
4564   jresult = (void *)result;
4565   return jresult;
4566 }
4567
4568
4569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
4570   void * jresult ;
4571   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4572   Dali::Vector2 result;
4573
4574   arg1 = (Dali::Vector2 *)jarg1;
4575   {
4576     try {
4577       result = ((Dali::Vector2 const *)arg1)->operator -();
4578     } catch (std::out_of_range& e) {
4579       {
4580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4581       };
4582     } catch (std::exception& e) {
4583       {
4584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4585       };
4586     } catch (...) {
4587       {
4588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4589       };
4590     }
4591   }
4592   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4593   return jresult;
4594 }
4595
4596
4597 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
4598   unsigned int jresult ;
4599   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4600   Dali::Vector2 *arg2 = 0 ;
4601   bool result;
4602
4603   arg1 = (Dali::Vector2 *)jarg1;
4604   arg2 = (Dali::Vector2 *)jarg2;
4605   if (!arg2) {
4606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4607     return 0;
4608   }
4609   {
4610     try {
4611       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
4612     } catch (std::out_of_range& e) {
4613       {
4614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4615       };
4616     } catch (std::exception& e) {
4617       {
4618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4619       };
4620     } catch (...) {
4621       {
4622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4623       };
4624     }
4625   }
4626   jresult = result;
4627   return jresult;
4628 }
4629
4630
4631 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
4632   unsigned int jresult ;
4633   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4634   Dali::Vector2 *arg2 = 0 ;
4635   bool result;
4636
4637   arg1 = (Dali::Vector2 *)jarg1;
4638   arg2 = (Dali::Vector2 *)jarg2;
4639   if (!arg2) {
4640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4641     return 0;
4642   }
4643   {
4644     try {
4645       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
4646     } catch (std::out_of_range& e) {
4647       {
4648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4649       };
4650     } catch (std::exception& e) {
4651       {
4652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4653       };
4654     } catch (...) {
4655       {
4656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4657       };
4658     }
4659   }
4660   jresult = result;
4661   return jresult;
4662 }
4663
4664
4665 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4666   float jresult ;
4667   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4668   unsigned int arg2 ;
4669   float *result = 0 ;
4670
4671   arg1 = (Dali::Vector2 *)jarg1;
4672   arg2 = (unsigned int)jarg2;
4673   {
4674     try {
4675       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
4676     } catch (std::out_of_range& e) {
4677       {
4678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4679       };
4680     } catch (std::exception& e) {
4681       {
4682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4683       };
4684     } catch (...) {
4685       {
4686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4687       };
4688     }
4689   }
4690   jresult = *result;
4691   return jresult;
4692 }
4693
4694
4695 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
4696   float jresult ;
4697   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4698   float result;
4699
4700   arg1 = (Dali::Vector2 *)jarg1;
4701   {
4702     try {
4703       result = (float)((Dali::Vector2 const *)arg1)->Length();
4704     } catch (std::out_of_range& e) {
4705       {
4706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4707       };
4708     } catch (std::exception& e) {
4709       {
4710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4711       };
4712     } catch (...) {
4713       {
4714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4715       };
4716     }
4717   }
4718   jresult = result;
4719   return jresult;
4720 }
4721
4722
4723 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
4724   float jresult ;
4725   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4726   float result;
4727
4728   arg1 = (Dali::Vector2 *)jarg1;
4729   {
4730     try {
4731       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
4732     } catch (std::out_of_range& e) {
4733       {
4734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4735       };
4736     } catch (std::exception& e) {
4737       {
4738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4739       };
4740     } catch (...) {
4741       {
4742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4743       };
4744     }
4745   }
4746   jresult = result;
4747   return jresult;
4748 }
4749
4750
4751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
4752   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4753
4754   arg1 = (Dali::Vector2 *)jarg1;
4755   {
4756     try {
4757       (arg1)->Normalize();
4758     } catch (std::out_of_range& e) {
4759       {
4760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4761       };
4762     } catch (std::exception& e) {
4763       {
4764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4765       };
4766     } catch (...) {
4767       {
4768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4769       };
4770     }
4771   }
4772 }
4773
4774
4775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4776   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4777   Dali::Vector2 *arg2 = 0 ;
4778   Dali::Vector2 *arg3 = 0 ;
4779
4780   arg1 = (Dali::Vector2 *)jarg1;
4781   arg2 = (Dali::Vector2 *)jarg2;
4782   if (!arg2) {
4783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4784     return ;
4785   }
4786   arg3 = (Dali::Vector2 *)jarg3;
4787   if (!arg3) {
4788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4789     return ;
4790   }
4791   {
4792     try {
4793       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
4794     } catch (std::out_of_range& e) {
4795       {
4796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4797       };
4798     } catch (std::exception& e) {
4799       {
4800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4801       };
4802     } catch (...) {
4803       {
4804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4805       };
4806     }
4807   }
4808 }
4809
4810
4811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
4812   void * jresult ;
4813   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4814   float *result = 0 ;
4815
4816   arg1 = (Dali::Vector2 *)jarg1;
4817   {
4818     try {
4819       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
4820     } catch (std::out_of_range& e) {
4821       {
4822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4823       };
4824     } catch (std::exception& e) {
4825       {
4826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4827       };
4828     } catch (...) {
4829       {
4830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4831       };
4832     }
4833   }
4834   jresult = (void *)result;
4835   return jresult;
4836 }
4837
4838
4839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
4840   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4841   float arg2 ;
4842
4843   arg1 = (Dali::Vector2 *)jarg1;
4844   arg2 = (float)jarg2;
4845   if (arg1) (arg1)->x = arg2;
4846 }
4847
4848
4849 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
4850   float jresult ;
4851   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4852   float result;
4853
4854   arg1 = (Dali::Vector2 *)jarg1;
4855   result = (float) ((arg1)->x);
4856   jresult = result;
4857   return jresult;
4858 }
4859
4860
4861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
4862   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4863   float arg2 ;
4864
4865   arg1 = (Dali::Vector2 *)jarg1;
4866   arg2 = (float)jarg2;
4867   if (arg1) (arg1)->width = arg2;
4868 }
4869
4870
4871 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
4872   float jresult ;
4873   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4874   float result;
4875
4876   arg1 = (Dali::Vector2 *)jarg1;
4877   result = (float) ((arg1)->width);
4878   jresult = result;
4879   return jresult;
4880 }
4881
4882
4883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
4884   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4885   float arg2 ;
4886
4887   arg1 = (Dali::Vector2 *)jarg1;
4888   arg2 = (float)jarg2;
4889   if (arg1) (arg1)->y = arg2;
4890 }
4891
4892
4893 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
4894   float jresult ;
4895   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4896   float result;
4897
4898   arg1 = (Dali::Vector2 *)jarg1;
4899   result = (float) ((arg1)->y);
4900   jresult = result;
4901   return jresult;
4902 }
4903
4904
4905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
4906   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4907   float arg2 ;
4908
4909   arg1 = (Dali::Vector2 *)jarg1;
4910   arg2 = (float)jarg2;
4911   if (arg1) (arg1)->height = arg2;
4912 }
4913
4914
4915 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
4916   float jresult ;
4917   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4918   float result;
4919
4920   arg1 = (Dali::Vector2 *)jarg1;
4921   result = (float) ((arg1)->height);
4922   jresult = result;
4923   return jresult;
4924 }
4925
4926
4927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
4928   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4929
4930   arg1 = (Dali::Vector2 *)jarg1;
4931   {
4932     try {
4933       delete arg1;
4934     } catch (std::out_of_range& e) {
4935       {
4936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4937       };
4938     } catch (std::exception& e) {
4939       {
4940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4941       };
4942     } catch (...) {
4943       {
4944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4945       };
4946     }
4947   }
4948 }
4949
4950
4951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
4952   void * jresult ;
4953   Dali::Vector2 *arg1 = 0 ;
4954   Dali::Vector2 *arg2 = 0 ;
4955   Dali::Vector2 result;
4956
4957   arg1 = (Dali::Vector2 *)jarg1;
4958   if (!arg1) {
4959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4960     return 0;
4961   }
4962   arg2 = (Dali::Vector2 *)jarg2;
4963   if (!arg2) {
4964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4965     return 0;
4966   }
4967   {
4968     try {
4969       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4970     } catch (std::out_of_range& e) {
4971       {
4972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4973       };
4974     } catch (std::exception& e) {
4975       {
4976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4977       };
4978     } catch (...) {
4979       {
4980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4981       };
4982     }
4983   }
4984   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4985   return jresult;
4986 }
4987
4988
4989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
4990   void * jresult ;
4991   Dali::Vector2 *arg1 = 0 ;
4992   Dali::Vector2 *arg2 = 0 ;
4993   Dali::Vector2 result;
4994
4995   arg1 = (Dali::Vector2 *)jarg1;
4996   if (!arg1) {
4997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4998     return 0;
4999   }
5000   arg2 = (Dali::Vector2 *)jarg2;
5001   if (!arg2) {
5002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5003     return 0;
5004   }
5005   {
5006     try {
5007       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5008     } catch (std::out_of_range& e) {
5009       {
5010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5011       };
5012     } catch (std::exception& e) {
5013       {
5014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5015       };
5016     } catch (...) {
5017       {
5018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5019       };
5020     }
5021   }
5022   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5023   return jresult;
5024 }
5025
5026
5027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5028   void * jresult ;
5029   Dali::Vector2 *arg1 = 0 ;
5030   float *arg2 = 0 ;
5031   float *arg3 = 0 ;
5032   float temp2 ;
5033   float temp3 ;
5034   Dali::Vector2 result;
5035
5036   arg1 = (Dali::Vector2 *)jarg1;
5037   if (!arg1) {
5038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5039     return 0;
5040   }
5041   temp2 = (float)jarg2;
5042   arg2 = &temp2;
5043   temp3 = (float)jarg3;
5044   arg3 = &temp3;
5045   {
5046     try {
5047       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5048     } catch (std::out_of_range& e) {
5049       {
5050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5051       };
5052     } catch (std::exception& e) {
5053       {
5054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5055       };
5056     } catch (...) {
5057       {
5058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5059       };
5060     }
5061   }
5062   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5063   return jresult;
5064 }
5065
5066
5067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5068   void * jresult ;
5069   Dali::Vector3 *result = 0 ;
5070
5071   {
5072     try {
5073       result = (Dali::Vector3 *)new Dali::Vector3();
5074     } catch (std::out_of_range& e) {
5075       {
5076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5077       };
5078     } catch (std::exception& e) {
5079       {
5080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5081       };
5082     } catch (...) {
5083       {
5084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5085       };
5086     }
5087   }
5088   jresult = (void *)result;
5089   return jresult;
5090 }
5091
5092
5093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5094   void * jresult ;
5095   float arg1 ;
5096   float arg2 ;
5097   float arg3 ;
5098   Dali::Vector3 *result = 0 ;
5099
5100   arg1 = (float)jarg1;
5101   arg2 = (float)jarg2;
5102   arg3 = (float)jarg3;
5103   {
5104     try {
5105       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5106     } catch (std::out_of_range& e) {
5107       {
5108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5109       };
5110     } catch (std::exception& e) {
5111       {
5112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5113       };
5114     } catch (...) {
5115       {
5116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5117       };
5118     }
5119   }
5120   jresult = (void *)result;
5121   return jresult;
5122 }
5123
5124
5125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5126   void * jresult ;
5127   float *arg1 = (float *) 0 ;
5128   Dali::Vector3 *result = 0 ;
5129
5130   arg1 = jarg1;
5131   {
5132     try {
5133       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5134     } catch (std::out_of_range& e) {
5135       {
5136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5137       };
5138     } catch (std::exception& e) {
5139       {
5140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5141       };
5142     } catch (...) {
5143       {
5144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5145       };
5146     }
5147   }
5148   jresult = (void *)result;
5149
5150
5151   return jresult;
5152 }
5153
5154
5155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5156   void * jresult ;
5157   Dali::Vector2 *arg1 = 0 ;
5158   Dali::Vector3 *result = 0 ;
5159
5160   arg1 = (Dali::Vector2 *)jarg1;
5161   if (!arg1) {
5162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5163     return 0;
5164   }
5165   {
5166     try {
5167       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5168     } catch (std::out_of_range& e) {
5169       {
5170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5171       };
5172     } catch (std::exception& e) {
5173       {
5174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5175       };
5176     } catch (...) {
5177       {
5178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5179       };
5180     }
5181   }
5182   jresult = (void *)result;
5183   return jresult;
5184 }
5185
5186
5187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5188   void * jresult ;
5189   Dali::Vector4 *arg1 = 0 ;
5190   Dali::Vector3 *result = 0 ;
5191
5192   arg1 = (Dali::Vector4 *)jarg1;
5193   if (!arg1) {
5194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5195     return 0;
5196   }
5197   {
5198     try {
5199       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5200     } catch (std::out_of_range& e) {
5201       {
5202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5203       };
5204     } catch (std::exception& e) {
5205       {
5206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5207       };
5208     } catch (...) {
5209       {
5210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5211       };
5212     }
5213   }
5214   jresult = (void *)result;
5215   return jresult;
5216 }
5217
5218
5219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5220   void * jresult ;
5221   Dali::Vector3 *result = 0 ;
5222
5223   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5224   jresult = (void *)result;
5225   return jresult;
5226 }
5227
5228
5229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5230   void * jresult ;
5231   Dali::Vector3 *result = 0 ;
5232
5233   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5234   jresult = (void *)result;
5235   return jresult;
5236 }
5237
5238
5239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5240   void * jresult ;
5241   Dali::Vector3 *result = 0 ;
5242
5243   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5244   jresult = (void *)result;
5245   return jresult;
5246 }
5247
5248
5249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5250   void * jresult ;
5251   Dali::Vector3 *result = 0 ;
5252
5253   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5254   jresult = (void *)result;
5255   return jresult;
5256 }
5257
5258
5259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5260   void * jresult ;
5261   Dali::Vector3 *result = 0 ;
5262
5263   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5264   jresult = (void *)result;
5265   return jresult;
5266 }
5267
5268
5269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5270   void * jresult ;
5271   Dali::Vector3 *result = 0 ;
5272
5273   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5274   jresult = (void *)result;
5275   return jresult;
5276 }
5277
5278
5279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5280   void * jresult ;
5281   Dali::Vector3 *result = 0 ;
5282
5283   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5284   jresult = (void *)result;
5285   return jresult;
5286 }
5287
5288
5289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5290   void * jresult ;
5291   Dali::Vector3 *result = 0 ;
5292
5293   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5294   jresult = (void *)result;
5295   return jresult;
5296 }
5297
5298
5299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5300   void * jresult ;
5301   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5302   float *arg2 = (float *) 0 ;
5303   Dali::Vector3 *result = 0 ;
5304
5305   arg1 = (Dali::Vector3 *)jarg1;
5306   arg2 = jarg2;
5307   {
5308     try {
5309       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5310     } catch (std::out_of_range& e) {
5311       {
5312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5313       };
5314     } catch (std::exception& e) {
5315       {
5316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5317       };
5318     } catch (...) {
5319       {
5320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5321       };
5322     }
5323   }
5324   jresult = (void *)result;
5325
5326
5327   return jresult;
5328 }
5329
5330
5331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5332   void * jresult ;
5333   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5334   Dali::Vector2 *arg2 = 0 ;
5335   Dali::Vector3 *result = 0 ;
5336
5337   arg1 = (Dali::Vector3 *)jarg1;
5338   arg2 = (Dali::Vector2 *)jarg2;
5339   if (!arg2) {
5340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5341     return 0;
5342   }
5343   {
5344     try {
5345       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5346     } catch (std::out_of_range& e) {
5347       {
5348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5349       };
5350     } catch (std::exception& e) {
5351       {
5352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5353       };
5354     } catch (...) {
5355       {
5356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5357       };
5358     }
5359   }
5360   jresult = (void *)result;
5361   return jresult;
5362 }
5363
5364
5365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5366   void * jresult ;
5367   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5368   Dali::Vector4 *arg2 = 0 ;
5369   Dali::Vector3 *result = 0 ;
5370
5371   arg1 = (Dali::Vector3 *)jarg1;
5372   arg2 = (Dali::Vector4 *)jarg2;
5373   if (!arg2) {
5374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5375     return 0;
5376   }
5377   {
5378     try {
5379       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5380     } catch (std::out_of_range& e) {
5381       {
5382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5383       };
5384     } catch (std::exception& e) {
5385       {
5386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5387       };
5388     } catch (...) {
5389       {
5390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5391       };
5392     }
5393   }
5394   jresult = (void *)result;
5395   return jresult;
5396 }
5397
5398
5399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5400   void * jresult ;
5401   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5402   Dali::Vector3 *arg2 = 0 ;
5403   Dali::Vector3 result;
5404
5405   arg1 = (Dali::Vector3 *)jarg1;
5406   arg2 = (Dali::Vector3 *)jarg2;
5407   if (!arg2) {
5408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5409     return 0;
5410   }
5411   {
5412     try {
5413       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5414     } catch (std::out_of_range& e) {
5415       {
5416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5417       };
5418     } catch (std::exception& e) {
5419       {
5420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5421       };
5422     } catch (...) {
5423       {
5424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5425       };
5426     }
5427   }
5428   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5429   return jresult;
5430 }
5431
5432
5433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5434   void * jresult ;
5435   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5436   Dali::Vector3 *arg2 = 0 ;
5437   Dali::Vector3 *result = 0 ;
5438
5439   arg1 = (Dali::Vector3 *)jarg1;
5440   arg2 = (Dali::Vector3 *)jarg2;
5441   if (!arg2) {
5442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5443     return 0;
5444   }
5445   {
5446     try {
5447       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5448     } catch (std::out_of_range& e) {
5449       {
5450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5451       };
5452     } catch (std::exception& e) {
5453       {
5454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5455       };
5456     } catch (...) {
5457       {
5458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5459       };
5460     }
5461   }
5462   jresult = (void *)result;
5463   return jresult;
5464 }
5465
5466
5467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5468   void * jresult ;
5469   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5470   Dali::Vector3 *arg2 = 0 ;
5471   Dali::Vector3 result;
5472
5473   arg1 = (Dali::Vector3 *)jarg1;
5474   arg2 = (Dali::Vector3 *)jarg2;
5475   if (!arg2) {
5476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5477     return 0;
5478   }
5479   {
5480     try {
5481       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
5482     } catch (std::out_of_range& e) {
5483       {
5484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5485       };
5486     } catch (std::exception& e) {
5487       {
5488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5489       };
5490     } catch (...) {
5491       {
5492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5493       };
5494     }
5495   }
5496   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5497   return jresult;
5498 }
5499
5500
5501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
5502   void * jresult ;
5503   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5504   Dali::Vector3 *arg2 = 0 ;
5505   Dali::Vector3 *result = 0 ;
5506
5507   arg1 = (Dali::Vector3 *)jarg1;
5508   arg2 = (Dali::Vector3 *)jarg2;
5509   if (!arg2) {
5510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5511     return 0;
5512   }
5513   {
5514     try {
5515       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
5516     } catch (std::out_of_range& e) {
5517       {
5518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5519       };
5520     } catch (std::exception& e) {
5521       {
5522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5523       };
5524     } catch (...) {
5525       {
5526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5527       };
5528     }
5529   }
5530   jresult = (void *)result;
5531   return jresult;
5532 }
5533
5534
5535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5536   void * jresult ;
5537   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5538   Dali::Vector3 *arg2 = 0 ;
5539   Dali::Vector3 result;
5540
5541   arg1 = (Dali::Vector3 *)jarg1;
5542   arg2 = (Dali::Vector3 *)jarg2;
5543   if (!arg2) {
5544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5545     return 0;
5546   }
5547   {
5548     try {
5549       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
5550     } catch (std::out_of_range& e) {
5551       {
5552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5553       };
5554     } catch (std::exception& e) {
5555       {
5556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5557       };
5558     } catch (...) {
5559       {
5560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5561       };
5562     }
5563   }
5564   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5565   return jresult;
5566 }
5567
5568
5569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
5570   void * jresult ;
5571   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5572   float arg2 ;
5573   Dali::Vector3 result;
5574
5575   arg1 = (Dali::Vector3 *)jarg1;
5576   arg2 = (float)jarg2;
5577   {
5578     try {
5579       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
5580     } catch (std::out_of_range& e) {
5581       {
5582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5583       };
5584     } catch (std::exception& e) {
5585       {
5586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5587       };
5588     } catch (...) {
5589       {
5590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5591       };
5592     }
5593   }
5594   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5595   return jresult;
5596 }
5597
5598
5599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
5600   void * jresult ;
5601   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5602   Dali::Vector3 *arg2 = 0 ;
5603   Dali::Vector3 *result = 0 ;
5604
5605   arg1 = (Dali::Vector3 *)jarg1;
5606   arg2 = (Dali::Vector3 *)jarg2;
5607   if (!arg2) {
5608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5609     return 0;
5610   }
5611   {
5612     try {
5613       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
5614     } catch (std::out_of_range& e) {
5615       {
5616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5617       };
5618     } catch (std::exception& e) {
5619       {
5620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5621       };
5622     } catch (...) {
5623       {
5624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5625       };
5626     }
5627   }
5628   jresult = (void *)result;
5629   return jresult;
5630 }
5631
5632
5633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
5634   void * jresult ;
5635   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5636   float arg2 ;
5637   Dali::Vector3 *result = 0 ;
5638
5639   arg1 = (Dali::Vector3 *)jarg1;
5640   arg2 = (float)jarg2;
5641   {
5642     try {
5643       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
5644     } catch (std::out_of_range& e) {
5645       {
5646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5647       };
5648     } catch (std::exception& e) {
5649       {
5650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5651       };
5652     } catch (...) {
5653       {
5654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5655       };
5656     }
5657   }
5658   jresult = (void *)result;
5659   return jresult;
5660 }
5661
5662
5663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
5664   void * jresult ;
5665   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5666   Dali::Quaternion *arg2 = 0 ;
5667   Dali::Vector3 *result = 0 ;
5668
5669   arg1 = (Dali::Vector3 *)jarg1;
5670   arg2 = (Dali::Quaternion *)jarg2;
5671   if (!arg2) {
5672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
5673     return 0;
5674   }
5675   {
5676     try {
5677       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
5678     } catch (std::out_of_range& e) {
5679       {
5680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5681       };
5682     } catch (std::exception& e) {
5683       {
5684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5685       };
5686     } catch (...) {
5687       {
5688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5689       };
5690     }
5691   }
5692   jresult = (void *)result;
5693   return jresult;
5694 }
5695
5696
5697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
5698   void * jresult ;
5699   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5700   Dali::Vector3 *arg2 = 0 ;
5701   Dali::Vector3 result;
5702
5703   arg1 = (Dali::Vector3 *)jarg1;
5704   arg2 = (Dali::Vector3 *)jarg2;
5705   if (!arg2) {
5706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5707     return 0;
5708   }
5709   {
5710     try {
5711       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
5712     } catch (std::out_of_range& e) {
5713       {
5714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5715       };
5716     } catch (std::exception& e) {
5717       {
5718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5719       };
5720     } catch (...) {
5721       {
5722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5723       };
5724     }
5725   }
5726   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5727   return jresult;
5728 }
5729
5730
5731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
5732   void * jresult ;
5733   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5734   float arg2 ;
5735   Dali::Vector3 result;
5736
5737   arg1 = (Dali::Vector3 *)jarg1;
5738   arg2 = (float)jarg2;
5739   {
5740     try {
5741       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
5742     } catch (std::out_of_range& e) {
5743       {
5744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5745       };
5746     } catch (std::exception& e) {
5747       {
5748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5749       };
5750     } catch (...) {
5751       {
5752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5753       };
5754     }
5755   }
5756   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5757   return jresult;
5758 }
5759
5760
5761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
5762   void * jresult ;
5763   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5764   Dali::Vector3 *arg2 = 0 ;
5765   Dali::Vector3 *result = 0 ;
5766
5767   arg1 = (Dali::Vector3 *)jarg1;
5768   arg2 = (Dali::Vector3 *)jarg2;
5769   if (!arg2) {
5770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5771     return 0;
5772   }
5773   {
5774     try {
5775       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
5776     } catch (std::out_of_range& e) {
5777       {
5778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5779       };
5780     } catch (std::exception& e) {
5781       {
5782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5783       };
5784     } catch (...) {
5785       {
5786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5787       };
5788     }
5789   }
5790   jresult = (void *)result;
5791   return jresult;
5792 }
5793
5794
5795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
5796   void * jresult ;
5797   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5798   float arg2 ;
5799   Dali::Vector3 *result = 0 ;
5800
5801   arg1 = (Dali::Vector3 *)jarg1;
5802   arg2 = (float)jarg2;
5803   {
5804     try {
5805       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
5806     } catch (std::out_of_range& e) {
5807       {
5808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5809       };
5810     } catch (std::exception& e) {
5811       {
5812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5813       };
5814     } catch (...) {
5815       {
5816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5817       };
5818     }
5819   }
5820   jresult = (void *)result;
5821   return jresult;
5822 }
5823
5824
5825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
5826   void * jresult ;
5827   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5828   Dali::Vector3 result;
5829
5830   arg1 = (Dali::Vector3 *)jarg1;
5831   {
5832     try {
5833       result = ((Dali::Vector3 const *)arg1)->operator -();
5834     } catch (std::out_of_range& e) {
5835       {
5836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5837       };
5838     } catch (std::exception& e) {
5839       {
5840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5841       };
5842     } catch (...) {
5843       {
5844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5845       };
5846     }
5847   }
5848   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5849   return jresult;
5850 }
5851
5852
5853 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
5854   unsigned int jresult ;
5855   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5856   Dali::Vector3 *arg2 = 0 ;
5857   bool result;
5858
5859   arg1 = (Dali::Vector3 *)jarg1;
5860   arg2 = (Dali::Vector3 *)jarg2;
5861   if (!arg2) {
5862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5863     return 0;
5864   }
5865   {
5866     try {
5867       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
5868     } catch (std::out_of_range& e) {
5869       {
5870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5871       };
5872     } catch (std::exception& e) {
5873       {
5874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5875       };
5876     } catch (...) {
5877       {
5878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5879       };
5880     }
5881   }
5882   jresult = result;
5883   return jresult;
5884 }
5885
5886
5887 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
5888   unsigned int jresult ;
5889   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5890   Dali::Vector3 *arg2 = 0 ;
5891   bool result;
5892
5893   arg1 = (Dali::Vector3 *)jarg1;
5894   arg2 = (Dali::Vector3 *)jarg2;
5895   if (!arg2) {
5896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5897     return 0;
5898   }
5899   {
5900     try {
5901       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
5902     } catch (std::out_of_range& e) {
5903       {
5904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5905       };
5906     } catch (std::exception& e) {
5907       {
5908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5909       };
5910     } catch (...) {
5911       {
5912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5913       };
5914     }
5915   }
5916   jresult = result;
5917   return jresult;
5918 }
5919
5920
5921 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5922   float jresult ;
5923   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5924   unsigned int arg2 ;
5925   float *result = 0 ;
5926
5927   arg1 = (Dali::Vector3 *)jarg1;
5928   arg2 = (unsigned int)jarg2;
5929   {
5930     try {
5931       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
5932     } catch (std::out_of_range& e) {
5933       {
5934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5935       };
5936     } catch (std::exception& e) {
5937       {
5938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5939       };
5940     } catch (...) {
5941       {
5942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5943       };
5944     }
5945   }
5946   jresult = *result;
5947   return jresult;
5948 }
5949
5950
5951 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
5952   float jresult ;
5953   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5954   Dali::Vector3 *arg2 = 0 ;
5955   float result;
5956
5957   arg1 = (Dali::Vector3 *)jarg1;
5958   arg2 = (Dali::Vector3 *)jarg2;
5959   if (!arg2) {
5960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5961     return 0;
5962   }
5963   {
5964     try {
5965       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
5966     } catch (std::out_of_range& e) {
5967       {
5968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5969       };
5970     } catch (std::exception& e) {
5971       {
5972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5973       };
5974     } catch (...) {
5975       {
5976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5977       };
5978     }
5979   }
5980   jresult = result;
5981   return jresult;
5982 }
5983
5984
5985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
5986   void * jresult ;
5987   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5988   Dali::Vector3 *arg2 = 0 ;
5989   Dali::Vector3 result;
5990
5991   arg1 = (Dali::Vector3 *)jarg1;
5992   arg2 = (Dali::Vector3 *)jarg2;
5993   if (!arg2) {
5994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5995     return 0;
5996   }
5997   {
5998     try {
5999       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6000     } catch (std::out_of_range& e) {
6001       {
6002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6003       };
6004     } catch (std::exception& e) {
6005       {
6006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6007       };
6008     } catch (...) {
6009       {
6010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6011       };
6012     }
6013   }
6014   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6015   return jresult;
6016 }
6017
6018
6019 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6020   float jresult ;
6021   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6022   float result;
6023
6024   arg1 = (Dali::Vector3 *)jarg1;
6025   {
6026     try {
6027       result = (float)((Dali::Vector3 const *)arg1)->Length();
6028     } catch (std::out_of_range& e) {
6029       {
6030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6031       };
6032     } catch (std::exception& e) {
6033       {
6034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6035       };
6036     } catch (...) {
6037       {
6038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6039       };
6040     }
6041   }
6042   jresult = result;
6043   return jresult;
6044 }
6045
6046
6047 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6048   float jresult ;
6049   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6050   float result;
6051
6052   arg1 = (Dali::Vector3 *)jarg1;
6053   {
6054     try {
6055       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6056     } catch (std::out_of_range& e) {
6057       {
6058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6059       };
6060     } catch (std::exception& e) {
6061       {
6062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6063       };
6064     } catch (...) {
6065       {
6066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6067       };
6068     }
6069   }
6070   jresult = result;
6071   return jresult;
6072 }
6073
6074
6075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6076   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6077
6078   arg1 = (Dali::Vector3 *)jarg1;
6079   {
6080     try {
6081       (arg1)->Normalize();
6082     } catch (std::out_of_range& e) {
6083       {
6084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6085       };
6086     } catch (std::exception& e) {
6087       {
6088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6089       };
6090     } catch (...) {
6091       {
6092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6093       };
6094     }
6095   }
6096 }
6097
6098
6099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6100   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6101   Dali::Vector3 *arg2 = 0 ;
6102   Dali::Vector3 *arg3 = 0 ;
6103
6104   arg1 = (Dali::Vector3 *)jarg1;
6105   arg2 = (Dali::Vector3 *)jarg2;
6106   if (!arg2) {
6107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6108     return ;
6109   }
6110   arg3 = (Dali::Vector3 *)jarg3;
6111   if (!arg3) {
6112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6113     return ;
6114   }
6115   {
6116     try {
6117       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6118     } catch (std::out_of_range& e) {
6119       {
6120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6121       };
6122     } catch (std::exception& e) {
6123       {
6124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6125       };
6126     } catch (...) {
6127       {
6128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6129       };
6130     }
6131   }
6132 }
6133
6134
6135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6136   void * jresult ;
6137   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6138   float *result = 0 ;
6139
6140   arg1 = (Dali::Vector3 *)jarg1;
6141   {
6142     try {
6143       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6144     } catch (std::out_of_range& e) {
6145       {
6146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6147       };
6148     } catch (std::exception& e) {
6149       {
6150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6151       };
6152     } catch (...) {
6153       {
6154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6155       };
6156     }
6157   }
6158   jresult = (void *)result;
6159   return jresult;
6160 }
6161
6162
6163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6164   void * jresult ;
6165   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6166   Dali::Vector2 *result = 0 ;
6167
6168   arg1 = (Dali::Vector3 *)jarg1;
6169   {
6170     try {
6171       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6172     } catch (std::out_of_range& e) {
6173       {
6174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6175       };
6176     } catch (std::exception& e) {
6177       {
6178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6179       };
6180     } catch (...) {
6181       {
6182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6183       };
6184     }
6185   }
6186   jresult = (void *)result;
6187   return jresult;
6188 }
6189
6190
6191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6192   void * jresult ;
6193   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6194   Dali::Vector2 *result = 0 ;
6195
6196   arg1 = (Dali::Vector3 *)jarg1;
6197   {
6198     try {
6199       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6200     } catch (std::out_of_range& e) {
6201       {
6202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6203       };
6204     } catch (std::exception& e) {
6205       {
6206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6207       };
6208     } catch (...) {
6209       {
6210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6211       };
6212     }
6213   }
6214   jresult = (void *)result;
6215   return jresult;
6216 }
6217
6218
6219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6220   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6221   float arg2 ;
6222
6223   arg1 = (Dali::Vector3 *)jarg1;
6224   arg2 = (float)jarg2;
6225   if (arg1) (arg1)->x = arg2;
6226 }
6227
6228
6229 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6230   float jresult ;
6231   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6232   float result;
6233
6234   arg1 = (Dali::Vector3 *)jarg1;
6235   result = (float) ((arg1)->x);
6236   jresult = result;
6237   return jresult;
6238 }
6239
6240
6241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6242   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6243   float arg2 ;
6244
6245   arg1 = (Dali::Vector3 *)jarg1;
6246   arg2 = (float)jarg2;
6247   if (arg1) (arg1)->width = arg2;
6248 }
6249
6250
6251 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6252   float jresult ;
6253   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6254   float result;
6255
6256   arg1 = (Dali::Vector3 *)jarg1;
6257   result = (float) ((arg1)->width);
6258   jresult = result;
6259   return jresult;
6260 }
6261
6262
6263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6264   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6265   float arg2 ;
6266
6267   arg1 = (Dali::Vector3 *)jarg1;
6268   arg2 = (float)jarg2;
6269   if (arg1) (arg1)->r = arg2;
6270 }
6271
6272
6273 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6274   float jresult ;
6275   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6276   float result;
6277
6278   arg1 = (Dali::Vector3 *)jarg1;
6279   result = (float) ((arg1)->r);
6280   jresult = result;
6281   return jresult;
6282 }
6283
6284
6285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6286   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6287   float arg2 ;
6288
6289   arg1 = (Dali::Vector3 *)jarg1;
6290   arg2 = (float)jarg2;
6291   if (arg1) (arg1)->y = arg2;
6292 }
6293
6294
6295 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6296   float jresult ;
6297   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6298   float result;
6299
6300   arg1 = (Dali::Vector3 *)jarg1;
6301   result = (float) ((arg1)->y);
6302   jresult = result;
6303   return jresult;
6304 }
6305
6306
6307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6308   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6309   float arg2 ;
6310
6311   arg1 = (Dali::Vector3 *)jarg1;
6312   arg2 = (float)jarg2;
6313   if (arg1) (arg1)->height = arg2;
6314 }
6315
6316
6317 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6318   float jresult ;
6319   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6320   float result;
6321
6322   arg1 = (Dali::Vector3 *)jarg1;
6323   result = (float) ((arg1)->height);
6324   jresult = result;
6325   return jresult;
6326 }
6327
6328
6329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
6330   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6331   float arg2 ;
6332
6333   arg1 = (Dali::Vector3 *)jarg1;
6334   arg2 = (float)jarg2;
6335   if (arg1) (arg1)->g = arg2;
6336 }
6337
6338
6339 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
6340   float jresult ;
6341   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6342   float result;
6343
6344   arg1 = (Dali::Vector3 *)jarg1;
6345   result = (float) ((arg1)->g);
6346   jresult = result;
6347   return jresult;
6348 }
6349
6350
6351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
6352   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6353   float arg2 ;
6354
6355   arg1 = (Dali::Vector3 *)jarg1;
6356   arg2 = (float)jarg2;
6357   if (arg1) (arg1)->z = arg2;
6358 }
6359
6360
6361 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
6362   float jresult ;
6363   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6364   float result;
6365
6366   arg1 = (Dali::Vector3 *)jarg1;
6367   result = (float) ((arg1)->z);
6368   jresult = result;
6369   return jresult;
6370 }
6371
6372
6373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
6374   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6375   float arg2 ;
6376
6377   arg1 = (Dali::Vector3 *)jarg1;
6378   arg2 = (float)jarg2;
6379   if (arg1) (arg1)->depth = arg2;
6380 }
6381
6382
6383 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
6384   float jresult ;
6385   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6386   float result;
6387
6388   arg1 = (Dali::Vector3 *)jarg1;
6389   result = (float) ((arg1)->depth);
6390   jresult = result;
6391   return jresult;
6392 }
6393
6394
6395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
6396   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6397   float arg2 ;
6398
6399   arg1 = (Dali::Vector3 *)jarg1;
6400   arg2 = (float)jarg2;
6401   if (arg1) (arg1)->b = arg2;
6402 }
6403
6404
6405 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
6406   float jresult ;
6407   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6408   float result;
6409
6410   arg1 = (Dali::Vector3 *)jarg1;
6411   result = (float) ((arg1)->b);
6412   jresult = result;
6413   return jresult;
6414 }
6415
6416
6417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
6418   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6419
6420   arg1 = (Dali::Vector3 *)jarg1;
6421   {
6422     try {
6423       delete arg1;
6424     } catch (std::out_of_range& e) {
6425       {
6426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6427       };
6428     } catch (std::exception& e) {
6429       {
6430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6431       };
6432     } catch (...) {
6433       {
6434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6435       };
6436     }
6437   }
6438 }
6439
6440
6441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
6442   void * jresult ;
6443   Dali::Vector3 *arg1 = 0 ;
6444   Dali::Vector3 *arg2 = 0 ;
6445   Dali::Vector3 result;
6446
6447   arg1 = (Dali::Vector3 *)jarg1;
6448   if (!arg1) {
6449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6450     return 0;
6451   }
6452   arg2 = (Dali::Vector3 *)jarg2;
6453   if (!arg2) {
6454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6455     return 0;
6456   }
6457   {
6458     try {
6459       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6460     } catch (std::out_of_range& e) {
6461       {
6462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6463       };
6464     } catch (std::exception& e) {
6465       {
6466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6467       };
6468     } catch (...) {
6469       {
6470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6471       };
6472     }
6473   }
6474   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6475   return jresult;
6476 }
6477
6478
6479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
6480   void * jresult ;
6481   Dali::Vector3 *arg1 = 0 ;
6482   Dali::Vector3 *arg2 = 0 ;
6483   Dali::Vector3 result;
6484
6485   arg1 = (Dali::Vector3 *)jarg1;
6486   if (!arg1) {
6487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6488     return 0;
6489   }
6490   arg2 = (Dali::Vector3 *)jarg2;
6491   if (!arg2) {
6492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6493     return 0;
6494   }
6495   {
6496     try {
6497       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6498     } catch (std::out_of_range& e) {
6499       {
6500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6501       };
6502     } catch (std::exception& e) {
6503       {
6504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6505       };
6506     } catch (...) {
6507       {
6508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6509       };
6510     }
6511   }
6512   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6513   return jresult;
6514 }
6515
6516
6517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
6518   void * jresult ;
6519   Dali::Vector3 *arg1 = 0 ;
6520   float *arg2 = 0 ;
6521   float *arg3 = 0 ;
6522   float temp2 ;
6523   float temp3 ;
6524   Dali::Vector3 result;
6525
6526   arg1 = (Dali::Vector3 *)jarg1;
6527   if (!arg1) {
6528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6529     return 0;
6530   }
6531   temp2 = (float)jarg2;
6532   arg2 = &temp2;
6533   temp3 = (float)jarg3;
6534   arg3 = &temp3;
6535   {
6536     try {
6537       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
6538     } catch (std::out_of_range& e) {
6539       {
6540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6541       };
6542     } catch (std::exception& e) {
6543       {
6544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6545       };
6546     } catch (...) {
6547       {
6548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6549       };
6550     }
6551   }
6552   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6553   return jresult;
6554 }
6555
6556
6557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
6558   void * jresult ;
6559   Dali::Vector4 *result = 0 ;
6560
6561   {
6562     try {
6563       result = (Dali::Vector4 *)new Dali::Vector4();
6564     } catch (std::out_of_range& e) {
6565       {
6566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6567       };
6568     } catch (std::exception& e) {
6569       {
6570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6571       };
6572     } catch (...) {
6573       {
6574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6575       };
6576     }
6577   }
6578   jresult = (void *)result;
6579   return jresult;
6580 }
6581
6582
6583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
6584   void * jresult ;
6585   float arg1 ;
6586   float arg2 ;
6587   float arg3 ;
6588   float arg4 ;
6589   Dali::Vector4 *result = 0 ;
6590
6591   arg1 = (float)jarg1;
6592   arg2 = (float)jarg2;
6593   arg3 = (float)jarg3;
6594   arg4 = (float)jarg4;
6595   {
6596     try {
6597       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
6598     } catch (std::out_of_range& e) {
6599       {
6600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6601       };
6602     } catch (std::exception& e) {
6603       {
6604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6605       };
6606     } catch (...) {
6607       {
6608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6609       };
6610     }
6611   }
6612   jresult = (void *)result;
6613   return jresult;
6614 }
6615
6616
6617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
6618   void * jresult ;
6619   float *arg1 = (float *) 0 ;
6620   Dali::Vector4 *result = 0 ;
6621
6622   arg1 = jarg1;
6623   {
6624     try {
6625       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
6626     } catch (std::out_of_range& e) {
6627       {
6628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6629       };
6630     } catch (std::exception& e) {
6631       {
6632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6633       };
6634     } catch (...) {
6635       {
6636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6637       };
6638     }
6639   }
6640   jresult = (void *)result;
6641
6642
6643   return jresult;
6644 }
6645
6646
6647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
6648   void * jresult ;
6649   Dali::Vector2 *arg1 = 0 ;
6650   Dali::Vector4 *result = 0 ;
6651
6652   arg1 = (Dali::Vector2 *)jarg1;
6653   if (!arg1) {
6654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6655     return 0;
6656   }
6657   {
6658     try {
6659       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
6660     } catch (std::out_of_range& e) {
6661       {
6662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6663       };
6664     } catch (std::exception& e) {
6665       {
6666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6667       };
6668     } catch (...) {
6669       {
6670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6671       };
6672     }
6673   }
6674   jresult = (void *)result;
6675   return jresult;
6676 }
6677
6678
6679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
6680   void * jresult ;
6681   Dali::Vector3 *arg1 = 0 ;
6682   Dali::Vector4 *result = 0 ;
6683
6684   arg1 = (Dali::Vector3 *)jarg1;
6685   if (!arg1) {
6686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6687     return 0;
6688   }
6689   {
6690     try {
6691       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
6692     } catch (std::out_of_range& e) {
6693       {
6694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6695       };
6696     } catch (std::exception& e) {
6697       {
6698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6699       };
6700     } catch (...) {
6701       {
6702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6703       };
6704     }
6705   }
6706   jresult = (void *)result;
6707   return jresult;
6708 }
6709
6710
6711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
6712   void * jresult ;
6713   Dali::Vector4 *result = 0 ;
6714
6715   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
6716   jresult = (void *)result;
6717   return jresult;
6718 }
6719
6720
6721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
6722   void * jresult ;
6723   Dali::Vector4 *result = 0 ;
6724
6725   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
6726   jresult = (void *)result;
6727   return jresult;
6728 }
6729
6730
6731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
6732   void * jresult ;
6733   Dali::Vector4 *result = 0 ;
6734
6735   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
6736   jresult = (void *)result;
6737   return jresult;
6738 }
6739
6740
6741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
6742   void * jresult ;
6743   Dali::Vector4 *result = 0 ;
6744
6745   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
6746   jresult = (void *)result;
6747   return jresult;
6748 }
6749
6750
6751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
6752   void * jresult ;
6753   Dali::Vector4 *result = 0 ;
6754
6755   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
6756   jresult = (void *)result;
6757   return jresult;
6758 }
6759
6760
6761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
6762   void * jresult ;
6763   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6764   float *arg2 = (float *) 0 ;
6765   Dali::Vector4 *result = 0 ;
6766
6767   arg1 = (Dali::Vector4 *)jarg1;
6768   arg2 = jarg2;
6769   {
6770     try {
6771       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
6772     } catch (std::out_of_range& e) {
6773       {
6774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6775       };
6776     } catch (std::exception& e) {
6777       {
6778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6779       };
6780     } catch (...) {
6781       {
6782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6783       };
6784     }
6785   }
6786   jresult = (void *)result;
6787
6788
6789   return jresult;
6790 }
6791
6792
6793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
6794   void * jresult ;
6795   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6796   Dali::Vector2 *arg2 = 0 ;
6797   Dali::Vector4 *result = 0 ;
6798
6799   arg1 = (Dali::Vector4 *)jarg1;
6800   arg2 = (Dali::Vector2 *)jarg2;
6801   if (!arg2) {
6802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6803     return 0;
6804   }
6805   {
6806     try {
6807       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
6808     } catch (std::out_of_range& e) {
6809       {
6810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6811       };
6812     } catch (std::exception& e) {
6813       {
6814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6815       };
6816     } catch (...) {
6817       {
6818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6819       };
6820     }
6821   }
6822   jresult = (void *)result;
6823   return jresult;
6824 }
6825
6826
6827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
6828   void * jresult ;
6829   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6830   Dali::Vector3 *arg2 = 0 ;
6831   Dali::Vector4 *result = 0 ;
6832
6833   arg1 = (Dali::Vector4 *)jarg1;
6834   arg2 = (Dali::Vector3 *)jarg2;
6835   if (!arg2) {
6836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6837     return 0;
6838   }
6839   {
6840     try {
6841       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
6842     } catch (std::out_of_range& e) {
6843       {
6844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6845       };
6846     } catch (std::exception& e) {
6847       {
6848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6849       };
6850     } catch (...) {
6851       {
6852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6853       };
6854     }
6855   }
6856   jresult = (void *)result;
6857   return jresult;
6858 }
6859
6860
6861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
6862   void * jresult ;
6863   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6864   Dali::Vector4 *arg2 = 0 ;
6865   Dali::Vector4 result;
6866
6867   arg1 = (Dali::Vector4 *)jarg1;
6868   arg2 = (Dali::Vector4 *)jarg2;
6869   if (!arg2) {
6870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6871     return 0;
6872   }
6873   {
6874     try {
6875       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
6876     } catch (std::out_of_range& e) {
6877       {
6878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6879       };
6880     } catch (std::exception& e) {
6881       {
6882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6883       };
6884     } catch (...) {
6885       {
6886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6887       };
6888     }
6889   }
6890   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6891   return jresult;
6892 }
6893
6894
6895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
6896   void * jresult ;
6897   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6898   Dali::Vector4 *arg2 = 0 ;
6899   Dali::Vector4 *result = 0 ;
6900
6901   arg1 = (Dali::Vector4 *)jarg1;
6902   arg2 = (Dali::Vector4 *)jarg2;
6903   if (!arg2) {
6904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6905     return 0;
6906   }
6907   {
6908     try {
6909       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
6910     } catch (std::out_of_range& e) {
6911       {
6912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6913       };
6914     } catch (std::exception& e) {
6915       {
6916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6917       };
6918     } catch (...) {
6919       {
6920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6921       };
6922     }
6923   }
6924   jresult = (void *)result;
6925   return jresult;
6926 }
6927
6928
6929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6930   void * jresult ;
6931   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6932   Dali::Vector4 *arg2 = 0 ;
6933   Dali::Vector4 result;
6934
6935   arg1 = (Dali::Vector4 *)jarg1;
6936   arg2 = (Dali::Vector4 *)jarg2;
6937   if (!arg2) {
6938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6939     return 0;
6940   }
6941   {
6942     try {
6943       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
6944     } catch (std::out_of_range& e) {
6945       {
6946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6947       };
6948     } catch (std::exception& e) {
6949       {
6950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6951       };
6952     } catch (...) {
6953       {
6954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6955       };
6956     }
6957   }
6958   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6959   return jresult;
6960 }
6961
6962
6963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
6964   void * jresult ;
6965   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6966   Dali::Vector4 *arg2 = 0 ;
6967   Dali::Vector4 *result = 0 ;
6968
6969   arg1 = (Dali::Vector4 *)jarg1;
6970   arg2 = (Dali::Vector4 *)jarg2;
6971   if (!arg2) {
6972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6973     return 0;
6974   }
6975   {
6976     try {
6977       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
6978     } catch (std::out_of_range& e) {
6979       {
6980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6981       };
6982     } catch (std::exception& e) {
6983       {
6984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6985       };
6986     } catch (...) {
6987       {
6988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6989       };
6990     }
6991   }
6992   jresult = (void *)result;
6993   return jresult;
6994 }
6995
6996
6997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6998   void * jresult ;
6999   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7000   Dali::Vector4 *arg2 = 0 ;
7001   Dali::Vector4 result;
7002
7003   arg1 = (Dali::Vector4 *)jarg1;
7004   arg2 = (Dali::Vector4 *)jarg2;
7005   if (!arg2) {
7006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7007     return 0;
7008   }
7009   {
7010     try {
7011       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7012     } catch (std::out_of_range& e) {
7013       {
7014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7015       };
7016     } catch (std::exception& e) {
7017       {
7018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7019       };
7020     } catch (...) {
7021       {
7022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7023       };
7024     }
7025   }
7026   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7027   return jresult;
7028 }
7029
7030
7031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7032   void * jresult ;
7033   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7034   float arg2 ;
7035   Dali::Vector4 result;
7036
7037   arg1 = (Dali::Vector4 *)jarg1;
7038   arg2 = (float)jarg2;
7039   {
7040     try {
7041       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7042     } catch (std::out_of_range& e) {
7043       {
7044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7045       };
7046     } catch (std::exception& e) {
7047       {
7048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7049       };
7050     } catch (...) {
7051       {
7052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7053       };
7054     }
7055   }
7056   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7057   return jresult;
7058 }
7059
7060
7061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7062   void * jresult ;
7063   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7064   Dali::Vector4 *arg2 = 0 ;
7065   Dali::Vector4 *result = 0 ;
7066
7067   arg1 = (Dali::Vector4 *)jarg1;
7068   arg2 = (Dali::Vector4 *)jarg2;
7069   if (!arg2) {
7070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7071     return 0;
7072   }
7073   {
7074     try {
7075       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7076     } catch (std::out_of_range& e) {
7077       {
7078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7079       };
7080     } catch (std::exception& e) {
7081       {
7082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7083       };
7084     } catch (...) {
7085       {
7086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7087       };
7088     }
7089   }
7090   jresult = (void *)result;
7091   return jresult;
7092 }
7093
7094
7095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7096   void * jresult ;
7097   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7098   float arg2 ;
7099   Dali::Vector4 *result = 0 ;
7100
7101   arg1 = (Dali::Vector4 *)jarg1;
7102   arg2 = (float)jarg2;
7103   {
7104     try {
7105       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7106     } catch (std::out_of_range& e) {
7107       {
7108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7109       };
7110     } catch (std::exception& e) {
7111       {
7112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7113       };
7114     } catch (...) {
7115       {
7116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7117       };
7118     }
7119   }
7120   jresult = (void *)result;
7121   return jresult;
7122 }
7123
7124
7125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7126   void * jresult ;
7127   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7128   Dali::Vector4 *arg2 = 0 ;
7129   Dali::Vector4 result;
7130
7131   arg1 = (Dali::Vector4 *)jarg1;
7132   arg2 = (Dali::Vector4 *)jarg2;
7133   if (!arg2) {
7134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7135     return 0;
7136   }
7137   {
7138     try {
7139       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7140     } catch (std::out_of_range& e) {
7141       {
7142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7143       };
7144     } catch (std::exception& e) {
7145       {
7146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7147       };
7148     } catch (...) {
7149       {
7150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7151       };
7152     }
7153   }
7154   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7155   return jresult;
7156 }
7157
7158
7159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7160   void * jresult ;
7161   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7162   float arg2 ;
7163   Dali::Vector4 result;
7164
7165   arg1 = (Dali::Vector4 *)jarg1;
7166   arg2 = (float)jarg2;
7167   {
7168     try {
7169       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7170     } catch (std::out_of_range& e) {
7171       {
7172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7173       };
7174     } catch (std::exception& e) {
7175       {
7176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7177       };
7178     } catch (...) {
7179       {
7180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7181       };
7182     }
7183   }
7184   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7185   return jresult;
7186 }
7187
7188
7189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7190   void * jresult ;
7191   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7192   Dali::Vector4 *arg2 = 0 ;
7193   Dali::Vector4 *result = 0 ;
7194
7195   arg1 = (Dali::Vector4 *)jarg1;
7196   arg2 = (Dali::Vector4 *)jarg2;
7197   if (!arg2) {
7198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7199     return 0;
7200   }
7201   {
7202     try {
7203       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7204     } catch (std::out_of_range& e) {
7205       {
7206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7207       };
7208     } catch (std::exception& e) {
7209       {
7210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7211       };
7212     } catch (...) {
7213       {
7214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7215       };
7216     }
7217   }
7218   jresult = (void *)result;
7219   return jresult;
7220 }
7221
7222
7223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7224   void * jresult ;
7225   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7226   float arg2 ;
7227   Dali::Vector4 *result = 0 ;
7228
7229   arg1 = (Dali::Vector4 *)jarg1;
7230   arg2 = (float)jarg2;
7231   {
7232     try {
7233       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
7234     } catch (std::out_of_range& e) {
7235       {
7236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7237       };
7238     } catch (std::exception& e) {
7239       {
7240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7241       };
7242     } catch (...) {
7243       {
7244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7245       };
7246     }
7247   }
7248   jresult = (void *)result;
7249   return jresult;
7250 }
7251
7252
7253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
7254   void * jresult ;
7255   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7256   Dali::Vector4 result;
7257
7258   arg1 = (Dali::Vector4 *)jarg1;
7259   {
7260     try {
7261       result = ((Dali::Vector4 const *)arg1)->operator -();
7262     } catch (std::out_of_range& e) {
7263       {
7264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7265       };
7266     } catch (std::exception& e) {
7267       {
7268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7269       };
7270     } catch (...) {
7271       {
7272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7273       };
7274     }
7275   }
7276   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7277   return jresult;
7278 }
7279
7280
7281 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
7282   unsigned int jresult ;
7283   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7284   Dali::Vector4 *arg2 = 0 ;
7285   bool result;
7286
7287   arg1 = (Dali::Vector4 *)jarg1;
7288   arg2 = (Dali::Vector4 *)jarg2;
7289   if (!arg2) {
7290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7291     return 0;
7292   }
7293   {
7294     try {
7295       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
7296     } catch (std::out_of_range& e) {
7297       {
7298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7299       };
7300     } catch (std::exception& e) {
7301       {
7302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7303       };
7304     } catch (...) {
7305       {
7306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7307       };
7308     }
7309   }
7310   jresult = result;
7311   return jresult;
7312 }
7313
7314
7315 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
7316   unsigned int jresult ;
7317   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7318   Dali::Vector4 *arg2 = 0 ;
7319   bool result;
7320
7321   arg1 = (Dali::Vector4 *)jarg1;
7322   arg2 = (Dali::Vector4 *)jarg2;
7323   if (!arg2) {
7324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7325     return 0;
7326   }
7327   {
7328     try {
7329       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
7330     } catch (std::out_of_range& e) {
7331       {
7332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7333       };
7334     } catch (std::exception& e) {
7335       {
7336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7337       };
7338     } catch (...) {
7339       {
7340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7341       };
7342     }
7343   }
7344   jresult = result;
7345   return jresult;
7346 }
7347
7348
7349 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
7350   float jresult ;
7351   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7352   unsigned int arg2 ;
7353   float *result = 0 ;
7354
7355   arg1 = (Dali::Vector4 *)jarg1;
7356   arg2 = (unsigned int)jarg2;
7357   {
7358     try {
7359       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
7360     } catch (std::out_of_range& e) {
7361       {
7362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7363       };
7364     } catch (std::exception& e) {
7365       {
7366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7367       };
7368     } catch (...) {
7369       {
7370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7371       };
7372     }
7373   }
7374   jresult = *result;
7375   return jresult;
7376 }
7377
7378
7379 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
7380   float jresult ;
7381   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7382   Dali::Vector3 *arg2 = 0 ;
7383   float result;
7384
7385   arg1 = (Dali::Vector4 *)jarg1;
7386   arg2 = (Dali::Vector3 *)jarg2;
7387   if (!arg2) {
7388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7389     return 0;
7390   }
7391   {
7392     try {
7393       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
7394     } catch (std::out_of_range& e) {
7395       {
7396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7397       };
7398     } catch (std::exception& e) {
7399       {
7400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7401       };
7402     } catch (...) {
7403       {
7404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7405       };
7406     }
7407   }
7408   jresult = result;
7409   return jresult;
7410 }
7411
7412
7413 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
7414   float jresult ;
7415   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7416   Dali::Vector4 *arg2 = 0 ;
7417   float result;
7418
7419   arg1 = (Dali::Vector4 *)jarg1;
7420   arg2 = (Dali::Vector4 *)jarg2;
7421   if (!arg2) {
7422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7423     return 0;
7424   }
7425   {
7426     try {
7427       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
7428     } catch (std::out_of_range& e) {
7429       {
7430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7431       };
7432     } catch (std::exception& e) {
7433       {
7434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7435       };
7436     } catch (...) {
7437       {
7438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7439       };
7440     }
7441   }
7442   jresult = result;
7443   return jresult;
7444 }
7445
7446
7447 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
7448   float jresult ;
7449   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7450   Dali::Vector4 *arg2 = 0 ;
7451   float result;
7452
7453   arg1 = (Dali::Vector4 *)jarg1;
7454   arg2 = (Dali::Vector4 *)jarg2;
7455   if (!arg2) {
7456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7457     return 0;
7458   }
7459   {
7460     try {
7461       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
7462     } catch (std::out_of_range& e) {
7463       {
7464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7465       };
7466     } catch (std::exception& e) {
7467       {
7468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7469       };
7470     } catch (...) {
7471       {
7472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7473       };
7474     }
7475   }
7476   jresult = result;
7477   return jresult;
7478 }
7479
7480
7481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
7482   void * jresult ;
7483   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7484   Dali::Vector4 *arg2 = 0 ;
7485   Dali::Vector4 result;
7486
7487   arg1 = (Dali::Vector4 *)jarg1;
7488   arg2 = (Dali::Vector4 *)jarg2;
7489   if (!arg2) {
7490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7491     return 0;
7492   }
7493   {
7494     try {
7495       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
7496     } catch (std::out_of_range& e) {
7497       {
7498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7499       };
7500     } catch (std::exception& e) {
7501       {
7502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7503       };
7504     } catch (...) {
7505       {
7506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7507       };
7508     }
7509   }
7510   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7511   return jresult;
7512 }
7513
7514
7515 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
7516   float jresult ;
7517   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7518   float result;
7519
7520   arg1 = (Dali::Vector4 *)jarg1;
7521   {
7522     try {
7523       result = (float)((Dali::Vector4 const *)arg1)->Length();
7524     } catch (std::out_of_range& e) {
7525       {
7526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7527       };
7528     } catch (std::exception& e) {
7529       {
7530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7531       };
7532     } catch (...) {
7533       {
7534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7535       };
7536     }
7537   }
7538   jresult = result;
7539   return jresult;
7540 }
7541
7542
7543 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
7544   float jresult ;
7545   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7546   float result;
7547
7548   arg1 = (Dali::Vector4 *)jarg1;
7549   {
7550     try {
7551       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
7552     } catch (std::out_of_range& e) {
7553       {
7554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7555       };
7556     } catch (std::exception& e) {
7557       {
7558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7559       };
7560     } catch (...) {
7561       {
7562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7563       };
7564     }
7565   }
7566   jresult = result;
7567   return jresult;
7568 }
7569
7570
7571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
7572   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7573
7574   arg1 = (Dali::Vector4 *)jarg1;
7575   {
7576     try {
7577       (arg1)->Normalize();
7578     } catch (std::out_of_range& e) {
7579       {
7580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7581       };
7582     } catch (std::exception& e) {
7583       {
7584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7585       };
7586     } catch (...) {
7587       {
7588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7589       };
7590     }
7591   }
7592 }
7593
7594
7595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
7596   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7597   Dali::Vector4 *arg2 = 0 ;
7598   Dali::Vector4 *arg3 = 0 ;
7599
7600   arg1 = (Dali::Vector4 *)jarg1;
7601   arg2 = (Dali::Vector4 *)jarg2;
7602   if (!arg2) {
7603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7604     return ;
7605   }
7606   arg3 = (Dali::Vector4 *)jarg3;
7607   if (!arg3) {
7608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7609     return ;
7610   }
7611   {
7612     try {
7613       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
7614     } catch (std::out_of_range& e) {
7615       {
7616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7617       };
7618     } catch (std::exception& e) {
7619       {
7620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7621       };
7622     } catch (...) {
7623       {
7624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7625       };
7626     }
7627   }
7628 }
7629
7630
7631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
7632   void * jresult ;
7633   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7634   float *result = 0 ;
7635
7636   arg1 = (Dali::Vector4 *)jarg1;
7637   {
7638     try {
7639       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
7640     } catch (std::out_of_range& e) {
7641       {
7642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7643       };
7644     } catch (std::exception& e) {
7645       {
7646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7647       };
7648     } catch (...) {
7649       {
7650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7651       };
7652     }
7653   }
7654   jresult = (void *)result;
7655   return jresult;
7656 }
7657
7658
7659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
7660   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7661   float arg2 ;
7662
7663   arg1 = (Dali::Vector4 *)jarg1;
7664   arg2 = (float)jarg2;
7665   if (arg1) (arg1)->x = arg2;
7666 }
7667
7668
7669 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
7670   float jresult ;
7671   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7672   float result;
7673
7674   arg1 = (Dali::Vector4 *)jarg1;
7675   result = (float) ((arg1)->x);
7676   jresult = result;
7677   return jresult;
7678 }
7679
7680
7681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
7682   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7683   float arg2 ;
7684
7685   arg1 = (Dali::Vector4 *)jarg1;
7686   arg2 = (float)jarg2;
7687   if (arg1) (arg1)->r = arg2;
7688 }
7689
7690
7691 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
7692   float jresult ;
7693   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7694   float result;
7695
7696   arg1 = (Dali::Vector4 *)jarg1;
7697   result = (float) ((arg1)->r);
7698   jresult = result;
7699   return jresult;
7700 }
7701
7702
7703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
7704   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7705   float arg2 ;
7706
7707   arg1 = (Dali::Vector4 *)jarg1;
7708   arg2 = (float)jarg2;
7709   if (arg1) (arg1)->s = arg2;
7710 }
7711
7712
7713 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
7714   float jresult ;
7715   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7716   float result;
7717
7718   arg1 = (Dali::Vector4 *)jarg1;
7719   result = (float) ((arg1)->s);
7720   jresult = result;
7721   return jresult;
7722 }
7723
7724
7725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
7726   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7727   float arg2 ;
7728
7729   arg1 = (Dali::Vector4 *)jarg1;
7730   arg2 = (float)jarg2;
7731   if (arg1) (arg1)->y = arg2;
7732 }
7733
7734
7735 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
7736   float jresult ;
7737   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7738   float result;
7739
7740   arg1 = (Dali::Vector4 *)jarg1;
7741   result = (float) ((arg1)->y);
7742   jresult = result;
7743   return jresult;
7744 }
7745
7746
7747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
7748   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7749   float arg2 ;
7750
7751   arg1 = (Dali::Vector4 *)jarg1;
7752   arg2 = (float)jarg2;
7753   if (arg1) (arg1)->g = arg2;
7754 }
7755
7756
7757 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
7758   float jresult ;
7759   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7760   float result;
7761
7762   arg1 = (Dali::Vector4 *)jarg1;
7763   result = (float) ((arg1)->g);
7764   jresult = result;
7765   return jresult;
7766 }
7767
7768
7769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
7770   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7771   float arg2 ;
7772
7773   arg1 = (Dali::Vector4 *)jarg1;
7774   arg2 = (float)jarg2;
7775   if (arg1) (arg1)->t = arg2;
7776 }
7777
7778
7779 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
7780   float jresult ;
7781   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7782   float result;
7783
7784   arg1 = (Dali::Vector4 *)jarg1;
7785   result = (float) ((arg1)->t);
7786   jresult = result;
7787   return jresult;
7788 }
7789
7790
7791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
7792   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7793   float arg2 ;
7794
7795   arg1 = (Dali::Vector4 *)jarg1;
7796   arg2 = (float)jarg2;
7797   if (arg1) (arg1)->z = arg2;
7798 }
7799
7800
7801 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
7802   float jresult ;
7803   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7804   float result;
7805
7806   arg1 = (Dali::Vector4 *)jarg1;
7807   result = (float) ((arg1)->z);
7808   jresult = result;
7809   return jresult;
7810 }
7811
7812
7813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
7814   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7815   float arg2 ;
7816
7817   arg1 = (Dali::Vector4 *)jarg1;
7818   arg2 = (float)jarg2;
7819   if (arg1) (arg1)->b = arg2;
7820 }
7821
7822
7823 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
7824   float jresult ;
7825   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7826   float result;
7827
7828   arg1 = (Dali::Vector4 *)jarg1;
7829   result = (float) ((arg1)->b);
7830   jresult = result;
7831   return jresult;
7832 }
7833
7834
7835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
7836   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7837   float arg2 ;
7838
7839   arg1 = (Dali::Vector4 *)jarg1;
7840   arg2 = (float)jarg2;
7841   if (arg1) (arg1)->p = arg2;
7842 }
7843
7844
7845 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
7846   float jresult ;
7847   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7848   float result;
7849
7850   arg1 = (Dali::Vector4 *)jarg1;
7851   result = (float) ((arg1)->p);
7852   jresult = result;
7853   return jresult;
7854 }
7855
7856
7857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
7858   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7859   float arg2 ;
7860
7861   arg1 = (Dali::Vector4 *)jarg1;
7862   arg2 = (float)jarg2;
7863   if (arg1) (arg1)->w = arg2;
7864 }
7865
7866
7867 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
7868   float jresult ;
7869   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7870   float result;
7871
7872   arg1 = (Dali::Vector4 *)jarg1;
7873   result = (float) ((arg1)->w);
7874   jresult = result;
7875   return jresult;
7876 }
7877
7878
7879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
7880   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7881   float arg2 ;
7882
7883   arg1 = (Dali::Vector4 *)jarg1;
7884   arg2 = (float)jarg2;
7885   if (arg1) (arg1)->a = arg2;
7886 }
7887
7888
7889 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
7890   float jresult ;
7891   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7892   float result;
7893
7894   arg1 = (Dali::Vector4 *)jarg1;
7895   result = (float) ((arg1)->a);
7896   jresult = result;
7897   return jresult;
7898 }
7899
7900
7901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
7902   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7903   float arg2 ;
7904
7905   arg1 = (Dali::Vector4 *)jarg1;
7906   arg2 = (float)jarg2;
7907   if (arg1) (arg1)->q = arg2;
7908 }
7909
7910
7911 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
7912   float jresult ;
7913   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7914   float result;
7915
7916   arg1 = (Dali::Vector4 *)jarg1;
7917   result = (float) ((arg1)->q);
7918   jresult = result;
7919   return jresult;
7920 }
7921
7922
7923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
7924   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7925
7926   arg1 = (Dali::Vector4 *)jarg1;
7927   {
7928     try {
7929       delete arg1;
7930     } catch (std::out_of_range& e) {
7931       {
7932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7933       };
7934     } catch (std::exception& e) {
7935       {
7936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7937       };
7938     } catch (...) {
7939       {
7940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7941       };
7942     }
7943   }
7944 }
7945
7946
7947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
7948   void * jresult ;
7949   Dali::Vector4 *arg1 = 0 ;
7950   Dali::Vector4 *arg2 = 0 ;
7951   Dali::Vector4 result;
7952
7953   arg1 = (Dali::Vector4 *)jarg1;
7954   if (!arg1) {
7955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7956     return 0;
7957   }
7958   arg2 = (Dali::Vector4 *)jarg2;
7959   if (!arg2) {
7960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7961     return 0;
7962   }
7963   {
7964     try {
7965       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7966     } catch (std::out_of_range& e) {
7967       {
7968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7969       };
7970     } catch (std::exception& e) {
7971       {
7972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7973       };
7974     } catch (...) {
7975       {
7976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7977       };
7978     }
7979   }
7980   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7981   return jresult;
7982 }
7983
7984
7985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
7986   void * jresult ;
7987   Dali::Vector4 *arg1 = 0 ;
7988   Dali::Vector4 *arg2 = 0 ;
7989   Dali::Vector4 result;
7990
7991   arg1 = (Dali::Vector4 *)jarg1;
7992   if (!arg1) {
7993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7994     return 0;
7995   }
7996   arg2 = (Dali::Vector4 *)jarg2;
7997   if (!arg2) {
7998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7999     return 0;
8000   }
8001   {
8002     try {
8003       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8004     } catch (std::out_of_range& e) {
8005       {
8006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8007       };
8008     } catch (std::exception& e) {
8009       {
8010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8011       };
8012     } catch (...) {
8013       {
8014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8015       };
8016     }
8017   }
8018   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8019   return jresult;
8020 }
8021
8022
8023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8024   void * jresult ;
8025   Dali::Vector4 *arg1 = 0 ;
8026   float *arg2 = 0 ;
8027   float *arg3 = 0 ;
8028   float temp2 ;
8029   float temp3 ;
8030   Dali::Vector4 result;
8031
8032   arg1 = (Dali::Vector4 *)jarg1;
8033   if (!arg1) {
8034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8035     return 0;
8036   }
8037   temp2 = (float)jarg2;
8038   arg2 = &temp2;
8039   temp3 = (float)jarg3;
8040   arg3 = &temp3;
8041   {
8042     try {
8043       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8044     } catch (std::out_of_range& e) {
8045       {
8046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8047       };
8048     } catch (std::exception& e) {
8049       {
8050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8051       };
8052     } catch (...) {
8053       {
8054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8055       };
8056     }
8057   }
8058   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8059   return jresult;
8060 }
8061
8062
8063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8064   void * jresult ;
8065   Dali::Uint16Pair *result = 0 ;
8066
8067   {
8068     try {
8069       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8070     } catch (std::out_of_range& e) {
8071       {
8072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8073       };
8074     } catch (std::exception& e) {
8075       {
8076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8077       };
8078     } catch (...) {
8079       {
8080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8081       };
8082     }
8083   }
8084   jresult = (void *)result;
8085   return jresult;
8086 }
8087
8088
8089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8090   void * jresult ;
8091   uint32_t arg1 ;
8092   uint32_t arg2 ;
8093   Dali::Uint16Pair *result = 0 ;
8094
8095   arg1 = (uint32_t)jarg1;
8096   arg2 = (uint32_t)jarg2;
8097   {
8098     try {
8099       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8100     } catch (std::out_of_range& e) {
8101       {
8102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8103       };
8104     } catch (std::exception& e) {
8105       {
8106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8107       };
8108     } catch (...) {
8109       {
8110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8111       };
8112     }
8113   }
8114   jresult = (void *)result;
8115   return jresult;
8116 }
8117
8118
8119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
8120   void * jresult ;
8121   Dali::Uint16Pair *arg1 = 0 ;
8122   Dali::Uint16Pair *result = 0 ;
8123
8124   arg1 = (Dali::Uint16Pair *)jarg1;
8125   if (!arg1) {
8126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8127     return 0;
8128   }
8129   {
8130     try {
8131       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
8132     } catch (std::out_of_range& e) {
8133       {
8134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8135       };
8136     } catch (std::exception& e) {
8137       {
8138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8139       };
8140     } catch (...) {
8141       {
8142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8143       };
8144     }
8145   }
8146   jresult = (void *)result;
8147   return jresult;
8148 }
8149
8150
8151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
8152   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8153   uint16_t arg2 ;
8154
8155   arg1 = (Dali::Uint16Pair *)jarg1;
8156   arg2 = (uint16_t)jarg2;
8157   {
8158     try {
8159       (arg1)->SetWidth(arg2);
8160     } catch (std::out_of_range& e) {
8161       {
8162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8163       };
8164     } catch (std::exception& e) {
8165       {
8166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8167       };
8168     } catch (...) {
8169       {
8170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8171       };
8172     }
8173   }
8174 }
8175
8176
8177 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
8178   unsigned short jresult ;
8179   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8180   uint16_t result;
8181
8182   arg1 = (Dali::Uint16Pair *)jarg1;
8183   {
8184     try {
8185       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
8186     } catch (std::out_of_range& e) {
8187       {
8188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8189       };
8190     } catch (std::exception& e) {
8191       {
8192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8193       };
8194     } catch (...) {
8195       {
8196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8197       };
8198     }
8199   }
8200   jresult = result;
8201   return jresult;
8202 }
8203
8204
8205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
8206   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8207   uint16_t arg2 ;
8208
8209   arg1 = (Dali::Uint16Pair *)jarg1;
8210   arg2 = (uint16_t)jarg2;
8211   {
8212     try {
8213       (arg1)->SetHeight(arg2);
8214     } catch (std::out_of_range& e) {
8215       {
8216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8217       };
8218     } catch (std::exception& e) {
8219       {
8220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8221       };
8222     } catch (...) {
8223       {
8224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8225       };
8226     }
8227   }
8228 }
8229
8230
8231 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
8232   unsigned short jresult ;
8233   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8234   uint16_t result;
8235
8236   arg1 = (Dali::Uint16Pair *)jarg1;
8237   {
8238     try {
8239       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
8240     } catch (std::out_of_range& e) {
8241       {
8242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8243       };
8244     } catch (std::exception& e) {
8245       {
8246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8247       };
8248     } catch (...) {
8249       {
8250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8251       };
8252     }
8253   }
8254   jresult = result;
8255   return jresult;
8256 }
8257
8258
8259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
8260   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8261   uint16_t arg2 ;
8262
8263   arg1 = (Dali::Uint16Pair *)jarg1;
8264   arg2 = (uint16_t)jarg2;
8265   {
8266     try {
8267       (arg1)->SetX(arg2);
8268     } catch (std::out_of_range& e) {
8269       {
8270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8271       };
8272     } catch (std::exception& e) {
8273       {
8274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8275       };
8276     } catch (...) {
8277       {
8278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8279       };
8280     }
8281   }
8282 }
8283
8284
8285 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
8286   unsigned short jresult ;
8287   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8288   uint16_t result;
8289
8290   arg1 = (Dali::Uint16Pair *)jarg1;
8291   {
8292     try {
8293       result = ((Dali::Uint16Pair const *)arg1)->GetX();
8294     } catch (std::out_of_range& e) {
8295       {
8296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8297       };
8298     } catch (std::exception& e) {
8299       {
8300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8301       };
8302     } catch (...) {
8303       {
8304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8305       };
8306     }
8307   }
8308   jresult = result;
8309   return jresult;
8310 }
8311
8312
8313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
8314   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8315   uint16_t arg2 ;
8316
8317   arg1 = (Dali::Uint16Pair *)jarg1;
8318   arg2 = (uint16_t)jarg2;
8319   {
8320     try {
8321       (arg1)->SetY(arg2);
8322     } catch (std::out_of_range& e) {
8323       {
8324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8325       };
8326     } catch (std::exception& e) {
8327       {
8328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8329       };
8330     } catch (...) {
8331       {
8332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8333       };
8334     }
8335   }
8336 }
8337
8338
8339 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
8340   unsigned short jresult ;
8341   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8342   uint16_t result;
8343
8344   arg1 = (Dali::Uint16Pair *)jarg1;
8345   {
8346     try {
8347       result = ((Dali::Uint16Pair const *)arg1)->GetY();
8348     } catch (std::out_of_range& e) {
8349       {
8350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8351       };
8352     } catch (std::exception& e) {
8353       {
8354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8355       };
8356     } catch (...) {
8357       {
8358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8359       };
8360     }
8361   }
8362   jresult = result;
8363   return jresult;
8364 }
8365
8366
8367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
8368   void * jresult ;
8369   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8370   Dali::Uint16Pair *arg2 = 0 ;
8371   Dali::Uint16Pair *result = 0 ;
8372
8373   arg1 = (Dali::Uint16Pair *)jarg1;
8374   arg2 = (Dali::Uint16Pair *)jarg2;
8375   if (!arg2) {
8376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8377     return 0;
8378   }
8379   {
8380     try {
8381       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
8382     } catch (std::out_of_range& e) {
8383       {
8384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8385       };
8386     } catch (std::exception& e) {
8387       {
8388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8389       };
8390     } catch (...) {
8391       {
8392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8393       };
8394     }
8395   }
8396   jresult = (void *)result;
8397   return jresult;
8398 }
8399
8400
8401 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
8402   unsigned int jresult ;
8403   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8404   Dali::Uint16Pair *arg2 = 0 ;
8405   bool result;
8406
8407   arg1 = (Dali::Uint16Pair *)jarg1;
8408   arg2 = (Dali::Uint16Pair *)jarg2;
8409   if (!arg2) {
8410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8411     return 0;
8412   }
8413   {
8414     try {
8415       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
8416     } catch (std::out_of_range& e) {
8417       {
8418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8419       };
8420     } catch (std::exception& e) {
8421       {
8422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8423       };
8424     } catch (...) {
8425       {
8426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8427       };
8428     }
8429   }
8430   jresult = result;
8431   return jresult;
8432 }
8433
8434
8435 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
8436   unsigned int jresult ;
8437   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8438   Dali::Uint16Pair *arg2 = 0 ;
8439   bool result;
8440
8441   arg1 = (Dali::Uint16Pair *)jarg1;
8442   arg2 = (Dali::Uint16Pair *)jarg2;
8443   if (!arg2) {
8444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8445     return 0;
8446   }
8447   {
8448     try {
8449       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
8450     } catch (std::out_of_range& e) {
8451       {
8452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8453       };
8454     } catch (std::exception& e) {
8455       {
8456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8457       };
8458     } catch (...) {
8459       {
8460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8461       };
8462     }
8463   }
8464   jresult = result;
8465   return jresult;
8466 }
8467
8468
8469 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
8470   unsigned int jresult ;
8471   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8472   Dali::Uint16Pair *arg2 = 0 ;
8473   bool result;
8474
8475   arg1 = (Dali::Uint16Pair *)jarg1;
8476   arg2 = (Dali::Uint16Pair *)jarg2;
8477   if (!arg2) {
8478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8479     return 0;
8480   }
8481   {
8482     try {
8483       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
8484     } catch (std::out_of_range& e) {
8485       {
8486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8487       };
8488     } catch (std::exception& e) {
8489       {
8490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8491       };
8492     } catch (...) {
8493       {
8494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8495       };
8496     }
8497   }
8498   jresult = result;
8499   return jresult;
8500 }
8501
8502
8503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
8504   unsigned int jresult ;
8505   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8506   Dali::Uint16Pair *arg2 = 0 ;
8507   bool result;
8508
8509   arg1 = (Dali::Uint16Pair *)jarg1;
8510   arg2 = (Dali::Uint16Pair *)jarg2;
8511   if (!arg2) {
8512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8513     return 0;
8514   }
8515   {
8516     try {
8517       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
8518     } catch (std::out_of_range& e) {
8519       {
8520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8521       };
8522     } catch (std::exception& e) {
8523       {
8524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8525       };
8526     } catch (...) {
8527       {
8528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8529       };
8530     }
8531   }
8532   jresult = result;
8533   return jresult;
8534 }
8535
8536
8537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
8538   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8539
8540   arg1 = (Dali::Uint16Pair *)jarg1;
8541   {
8542     try {
8543       delete arg1;
8544     } catch (std::out_of_range& e) {
8545       {
8546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8547       };
8548     } catch (std::exception& e) {
8549       {
8550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8551       };
8552     } catch (...) {
8553       {
8554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8555       };
8556     }
8557   }
8558 }
8559
8560
8561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
8562   void * jresult ;
8563   Dali::Degree *result = 0 ;
8564
8565   {
8566     try {
8567       result = (Dali::Degree *)new Dali::Degree();
8568     } catch (std::out_of_range& e) {
8569       {
8570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8571       };
8572     } catch (std::exception& e) {
8573       {
8574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8575       };
8576     } catch (...) {
8577       {
8578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8579       };
8580     }
8581   }
8582   jresult = (void *)result;
8583   return jresult;
8584 }
8585
8586
8587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
8588   void * jresult ;
8589   float arg1 ;
8590   Dali::Degree *result = 0 ;
8591
8592   arg1 = (float)jarg1;
8593   {
8594     try {
8595       result = (Dali::Degree *)new Dali::Degree(arg1);
8596     } catch (std::out_of_range& e) {
8597       {
8598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8599       };
8600     } catch (std::exception& e) {
8601       {
8602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8603       };
8604     } catch (...) {
8605       {
8606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8607       };
8608     }
8609   }
8610   jresult = (void *)result;
8611   return jresult;
8612 }
8613
8614
8615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
8616   void * jresult ;
8617   Dali::Radian arg1 ;
8618   Dali::Radian *argp1 ;
8619   Dali::Degree *result = 0 ;
8620
8621   argp1 = (Dali::Radian *)jarg1;
8622   if (!argp1) {
8623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8624     return 0;
8625   }
8626   arg1 = *argp1;
8627   {
8628     try {
8629       result = (Dali::Degree *)new Dali::Degree(arg1);
8630     } catch (std::out_of_range& e) {
8631       {
8632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8633       };
8634     } catch (std::exception& e) {
8635       {
8636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8637       };
8638     } catch (...) {
8639       {
8640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8641       };
8642     }
8643   }
8644   jresult = (void *)result;
8645   return jresult;
8646 }
8647
8648
8649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
8650   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8651   float arg2 ;
8652
8653   arg1 = (Dali::Degree *)jarg1;
8654   arg2 = (float)jarg2;
8655   if (arg1) (arg1)->degree = arg2;
8656 }
8657
8658
8659 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
8660   float jresult ;
8661   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8662   float result;
8663
8664   arg1 = (Dali::Degree *)jarg1;
8665   result = (float) ((arg1)->degree);
8666   jresult = result;
8667   return jresult;
8668 }
8669
8670
8671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
8672   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8673
8674   arg1 = (Dali::Degree *)jarg1;
8675   {
8676     try {
8677       delete arg1;
8678     } catch (std::out_of_range& e) {
8679       {
8680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8681       };
8682     } catch (std::exception& e) {
8683       {
8684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8685       };
8686     } catch (...) {
8687       {
8688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8689       };
8690     }
8691   }
8692 }
8693
8694
8695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
8696   void * jresult ;
8697   Dali::Radian *result = 0 ;
8698
8699   result = (Dali::Radian *)&Dali::ANGLE_360;
8700   jresult = (void *)result;
8701   return jresult;
8702 }
8703
8704
8705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
8706   void * jresult ;
8707   Dali::Radian *result = 0 ;
8708
8709   result = (Dali::Radian *)&Dali::ANGLE_315;
8710   jresult = (void *)result;
8711   return jresult;
8712 }
8713
8714
8715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
8716   void * jresult ;
8717   Dali::Radian *result = 0 ;
8718
8719   result = (Dali::Radian *)&Dali::ANGLE_270;
8720   jresult = (void *)result;
8721   return jresult;
8722 }
8723
8724
8725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
8726   void * jresult ;
8727   Dali::Radian *result = 0 ;
8728
8729   result = (Dali::Radian *)&Dali::ANGLE_225;
8730   jresult = (void *)result;
8731   return jresult;
8732 }
8733
8734
8735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
8736   void * jresult ;
8737   Dali::Radian *result = 0 ;
8738
8739   result = (Dali::Radian *)&Dali::ANGLE_180;
8740   jresult = (void *)result;
8741   return jresult;
8742 }
8743
8744
8745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
8746   void * jresult ;
8747   Dali::Radian *result = 0 ;
8748
8749   result = (Dali::Radian *)&Dali::ANGLE_135;
8750   jresult = (void *)result;
8751   return jresult;
8752 }
8753
8754
8755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
8756   void * jresult ;
8757   Dali::Radian *result = 0 ;
8758
8759   result = (Dali::Radian *)&Dali::ANGLE_120;
8760   jresult = (void *)result;
8761   return jresult;
8762 }
8763
8764
8765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
8766   void * jresult ;
8767   Dali::Radian *result = 0 ;
8768
8769   result = (Dali::Radian *)&Dali::ANGLE_90;
8770   jresult = (void *)result;
8771   return jresult;
8772 }
8773
8774
8775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
8776   void * jresult ;
8777   Dali::Radian *result = 0 ;
8778
8779   result = (Dali::Radian *)&Dali::ANGLE_60;
8780   jresult = (void *)result;
8781   return jresult;
8782 }
8783
8784
8785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
8786   void * jresult ;
8787   Dali::Radian *result = 0 ;
8788
8789   result = (Dali::Radian *)&Dali::ANGLE_45;
8790   jresult = (void *)result;
8791   return jresult;
8792 }
8793
8794
8795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
8796   void * jresult ;
8797   Dali::Radian *result = 0 ;
8798
8799   result = (Dali::Radian *)&Dali::ANGLE_30;
8800   jresult = (void *)result;
8801   return jresult;
8802 }
8803
8804
8805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
8806   void * jresult ;
8807   Dali::Radian *result = 0 ;
8808
8809   result = (Dali::Radian *)&Dali::ANGLE_0;
8810   jresult = (void *)result;
8811   return jresult;
8812 }
8813
8814
8815 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
8816   unsigned int jresult ;
8817   Dali::Degree *arg1 = 0 ;
8818   Dali::Degree *arg2 = 0 ;
8819   bool result;
8820
8821   arg1 = (Dali::Degree *)jarg1;
8822   if (!arg1) {
8823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8824     return 0;
8825   }
8826   arg2 = (Dali::Degree *)jarg2;
8827   if (!arg2) {
8828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8829     return 0;
8830   }
8831   {
8832     try {
8833       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8834     } catch (std::out_of_range& e) {
8835       {
8836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8837       };
8838     } catch (std::exception& e) {
8839       {
8840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8841       };
8842     } catch (...) {
8843       {
8844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8845       };
8846     }
8847   }
8848   jresult = result;
8849   return jresult;
8850 }
8851
8852
8853 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
8854   unsigned int jresult ;
8855   Dali::Degree *arg1 = 0 ;
8856   Dali::Degree *arg2 = 0 ;
8857   bool result;
8858
8859   arg1 = (Dali::Degree *)jarg1;
8860   if (!arg1) {
8861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8862     return 0;
8863   }
8864   arg2 = (Dali::Degree *)jarg2;
8865   if (!arg2) {
8866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8867     return 0;
8868   }
8869   {
8870     try {
8871       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8872     } catch (std::out_of_range& e) {
8873       {
8874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8875       };
8876     } catch (std::exception& e) {
8877       {
8878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8879       };
8880     } catch (...) {
8881       {
8882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8883       };
8884     }
8885   }
8886   jresult = result;
8887   return jresult;
8888 }
8889
8890
8891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
8892   void * jresult ;
8893   Dali::Degree arg1 ;
8894   float arg2 ;
8895   float arg3 ;
8896   Dali::Degree *argp1 ;
8897   Dali::Degree result;
8898
8899   argp1 = (Dali::Degree *)jarg1;
8900   if (!argp1) {
8901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8902     return 0;
8903   }
8904   arg1 = *argp1;
8905   arg2 = (float)jarg2;
8906   arg3 = (float)jarg3;
8907   {
8908     try {
8909       result = Dali::Clamp(arg1,arg2,arg3);
8910     } catch (std::out_of_range& e) {
8911       {
8912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8913       };
8914     } catch (std::exception& e) {
8915       {
8916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8917       };
8918     } catch (...) {
8919       {
8920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8921       };
8922     }
8923   }
8924   jresult = new Dali::Degree((const Dali::Degree &)result);
8925   return jresult;
8926 }
8927
8928
8929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
8930   void * jresult ;
8931   Dali::Radian *result = 0 ;
8932
8933   {
8934     try {
8935       result = (Dali::Radian *)new Dali::Radian();
8936     } catch (std::out_of_range& e) {
8937       {
8938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8939       };
8940     } catch (std::exception& e) {
8941       {
8942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8943       };
8944     } catch (...) {
8945       {
8946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8947       };
8948     }
8949   }
8950   jresult = (void *)result;
8951   return jresult;
8952 }
8953
8954
8955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
8956   void * jresult ;
8957   float arg1 ;
8958   Dali::Radian *result = 0 ;
8959
8960   arg1 = (float)jarg1;
8961   {
8962     try {
8963       result = (Dali::Radian *)new Dali::Radian(arg1);
8964     } catch (std::out_of_range& e) {
8965       {
8966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8967       };
8968     } catch (std::exception& e) {
8969       {
8970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8971       };
8972     } catch (...) {
8973       {
8974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8975       };
8976     }
8977   }
8978   jresult = (void *)result;
8979   return jresult;
8980 }
8981
8982
8983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
8984   void * jresult ;
8985   Dali::Degree arg1 ;
8986   Dali::Degree *argp1 ;
8987   Dali::Radian *result = 0 ;
8988
8989   argp1 = (Dali::Degree *)jarg1;
8990   if (!argp1) {
8991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8992     return 0;
8993   }
8994   arg1 = *argp1;
8995   {
8996     try {
8997       result = (Dali::Radian *)new Dali::Radian(arg1);
8998     } catch (std::out_of_range& e) {
8999       {
9000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9001       };
9002     } catch (std::exception& e) {
9003       {
9004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9005       };
9006     } catch (...) {
9007       {
9008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9009       };
9010     }
9011   }
9012   jresult = (void *)result;
9013   return jresult;
9014 }
9015
9016
9017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
9018   void * jresult ;
9019   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9020   float arg2 ;
9021   Dali::Radian *result = 0 ;
9022
9023   arg1 = (Dali::Radian *)jarg1;
9024   arg2 = (float)jarg2;
9025   {
9026     try {
9027       result = (Dali::Radian *) &(arg1)->operator =(arg2);
9028     } catch (std::out_of_range& e) {
9029       {
9030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9031       };
9032     } catch (std::exception& e) {
9033       {
9034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9035       };
9036     } catch (...) {
9037       {
9038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9039       };
9040     }
9041   }
9042   jresult = (void *)result;
9043   return jresult;
9044 }
9045
9046
9047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
9048   void * jresult ;
9049   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9050   Dali::Degree arg2 ;
9051   Dali::Degree *argp2 ;
9052   Dali::Radian *result = 0 ;
9053
9054   arg1 = (Dali::Radian *)jarg1;
9055   argp2 = (Dali::Degree *)jarg2;
9056   if (!argp2) {
9057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9058     return 0;
9059   }
9060   arg2 = *argp2;
9061   {
9062     try {
9063       result = (Dali::Radian *) &(arg1)->operator =(arg2);
9064     } catch (std::out_of_range& e) {
9065       {
9066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9067       };
9068     } catch (std::exception& e) {
9069       {
9070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9071       };
9072     } catch (...) {
9073       {
9074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9075       };
9076     }
9077   }
9078   jresult = (void *)result;
9079   return jresult;
9080 }
9081
9082
9083 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
9084   float jresult ;
9085   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9086   float result;
9087
9088   arg1 = (Dali::Radian *)jarg1;
9089   {
9090     try {
9091       result = (float)((Dali::Radian const *)arg1)->operator float();
9092     } catch (std::out_of_range& e) {
9093       {
9094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9095       };
9096     } catch (std::exception& e) {
9097       {
9098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9099       };
9100     } catch (...) {
9101       {
9102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9103       };
9104     }
9105   }
9106   jresult = result;
9107   return jresult;
9108 }
9109
9110
9111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
9112   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9113   float arg2 ;
9114
9115   arg1 = (Dali::Radian *)jarg1;
9116   arg2 = (float)jarg2;
9117   if (arg1) (arg1)->radian = arg2;
9118 }
9119
9120
9121 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
9122   float jresult ;
9123   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9124   float result;
9125
9126   arg1 = (Dali::Radian *)jarg1;
9127   result = (float) ((arg1)->radian);
9128   jresult = result;
9129   return jresult;
9130 }
9131
9132
9133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
9134   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9135
9136   arg1 = (Dali::Radian *)jarg1;
9137   {
9138     try {
9139       delete arg1;
9140     } catch (std::out_of_range& e) {
9141       {
9142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9143       };
9144     } catch (std::exception& e) {
9145       {
9146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9147       };
9148     } catch (...) {
9149       {
9150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9151       };
9152     }
9153   }
9154 }
9155
9156
9157 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
9158   unsigned int jresult ;
9159   Dali::Radian arg1 ;
9160   Dali::Radian arg2 ;
9161   Dali::Radian *argp1 ;
9162   Dali::Radian *argp2 ;
9163   bool result;
9164
9165   argp1 = (Dali::Radian *)jarg1;
9166   if (!argp1) {
9167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9168     return 0;
9169   }
9170   arg1 = *argp1;
9171   argp2 = (Dali::Radian *)jarg2;
9172   if (!argp2) {
9173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9174     return 0;
9175   }
9176   arg2 = *argp2;
9177   {
9178     try {
9179       result = (bool)Dali::operator ==(arg1,arg2);
9180     } catch (std::out_of_range& e) {
9181       {
9182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9183       };
9184     } catch (std::exception& e) {
9185       {
9186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9187       };
9188     } catch (...) {
9189       {
9190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9191       };
9192     }
9193   }
9194   jresult = result;
9195   return jresult;
9196 }
9197
9198
9199 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
9200   unsigned int jresult ;
9201   Dali::Radian arg1 ;
9202   Dali::Radian arg2 ;
9203   Dali::Radian *argp1 ;
9204   Dali::Radian *argp2 ;
9205   bool result;
9206
9207   argp1 = (Dali::Radian *)jarg1;
9208   if (!argp1) {
9209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9210     return 0;
9211   }
9212   arg1 = *argp1;
9213   argp2 = (Dali::Radian *)jarg2;
9214   if (!argp2) {
9215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9216     return 0;
9217   }
9218   arg2 = *argp2;
9219   {
9220     try {
9221       result = (bool)Dali::operator !=(arg1,arg2);
9222     } catch (std::out_of_range& e) {
9223       {
9224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9225       };
9226     } catch (std::exception& e) {
9227       {
9228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9229       };
9230     } catch (...) {
9231       {
9232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9233       };
9234     }
9235   }
9236   jresult = result;
9237   return jresult;
9238 }
9239
9240
9241 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
9242   unsigned int jresult ;
9243   Dali::Radian arg1 ;
9244   Dali::Degree arg2 ;
9245   Dali::Radian *argp1 ;
9246   Dali::Degree *argp2 ;
9247   bool result;
9248
9249   argp1 = (Dali::Radian *)jarg1;
9250   if (!argp1) {
9251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9252     return 0;
9253   }
9254   arg1 = *argp1;
9255   argp2 = (Dali::Degree *)jarg2;
9256   if (!argp2) {
9257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9258     return 0;
9259   }
9260   arg2 = *argp2;
9261   {
9262     try {
9263       result = (bool)Dali::operator ==(arg1,arg2);
9264     } catch (std::out_of_range& e) {
9265       {
9266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9267       };
9268     } catch (std::exception& e) {
9269       {
9270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9271       };
9272     } catch (...) {
9273       {
9274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9275       };
9276     }
9277   }
9278   jresult = result;
9279   return jresult;
9280 }
9281
9282
9283 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
9284   unsigned int jresult ;
9285   Dali::Radian arg1 ;
9286   Dali::Degree arg2 ;
9287   Dali::Radian *argp1 ;
9288   Dali::Degree *argp2 ;
9289   bool result;
9290
9291   argp1 = (Dali::Radian *)jarg1;
9292   if (!argp1) {
9293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9294     return 0;
9295   }
9296   arg1 = *argp1;
9297   argp2 = (Dali::Degree *)jarg2;
9298   if (!argp2) {
9299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9300     return 0;
9301   }
9302   arg2 = *argp2;
9303   {
9304     try {
9305       result = (bool)Dali::operator !=(arg1,arg2);
9306     } catch (std::out_of_range& e) {
9307       {
9308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9309       };
9310     } catch (std::exception& e) {
9311       {
9312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9313       };
9314     } catch (...) {
9315       {
9316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9317       };
9318     }
9319   }
9320   jresult = result;
9321   return jresult;
9322 }
9323
9324
9325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
9326   unsigned int jresult ;
9327   Dali::Degree arg1 ;
9328   Dali::Radian arg2 ;
9329   Dali::Degree *argp1 ;
9330   Dali::Radian *argp2 ;
9331   bool result;
9332
9333   argp1 = (Dali::Degree *)jarg1;
9334   if (!argp1) {
9335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9336     return 0;
9337   }
9338   arg1 = *argp1;
9339   argp2 = (Dali::Radian *)jarg2;
9340   if (!argp2) {
9341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9342     return 0;
9343   }
9344   arg2 = *argp2;
9345   {
9346     try {
9347       result = (bool)Dali::operator ==(arg1,arg2);
9348     } catch (std::out_of_range& e) {
9349       {
9350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9351       };
9352     } catch (std::exception& e) {
9353       {
9354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9355       };
9356     } catch (...) {
9357       {
9358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9359       };
9360     }
9361   }
9362   jresult = result;
9363   return jresult;
9364 }
9365
9366
9367 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
9368   unsigned int jresult ;
9369   Dali::Degree arg1 ;
9370   Dali::Radian arg2 ;
9371   Dali::Degree *argp1 ;
9372   Dali::Radian *argp2 ;
9373   bool result;
9374
9375   argp1 = (Dali::Degree *)jarg1;
9376   if (!argp1) {
9377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9378     return 0;
9379   }
9380   arg1 = *argp1;
9381   argp2 = (Dali::Radian *)jarg2;
9382   if (!argp2) {
9383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9384     return 0;
9385   }
9386   arg2 = *argp2;
9387   {
9388     try {
9389       result = (bool)Dali::operator !=(arg1,arg2);
9390     } catch (std::out_of_range& e) {
9391       {
9392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9393       };
9394     } catch (std::exception& e) {
9395       {
9396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9397       };
9398     } catch (...) {
9399       {
9400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9401       };
9402     }
9403   }
9404   jresult = result;
9405   return jresult;
9406 }
9407
9408
9409 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
9410   unsigned int jresult ;
9411   Dali::Radian arg1 ;
9412   Dali::Radian arg2 ;
9413   Dali::Radian *argp1 ;
9414   Dali::Radian *argp2 ;
9415   bool result;
9416
9417   argp1 = (Dali::Radian *)jarg1;
9418   if (!argp1) {
9419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9420     return 0;
9421   }
9422   arg1 = *argp1;
9423   argp2 = (Dali::Radian *)jarg2;
9424   if (!argp2) {
9425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9426     return 0;
9427   }
9428   arg2 = *argp2;
9429   {
9430     try {
9431       result = (bool)Dali::operator >(arg1,arg2);
9432     } catch (std::out_of_range& e) {
9433       {
9434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9435       };
9436     } catch (std::exception& e) {
9437       {
9438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9439       };
9440     } catch (...) {
9441       {
9442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9443       };
9444     }
9445   }
9446   jresult = result;
9447   return jresult;
9448 }
9449
9450
9451 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
9452   unsigned int jresult ;
9453   Dali::Radian arg1 ;
9454   Dali::Degree arg2 ;
9455   Dali::Radian *argp1 ;
9456   Dali::Degree *argp2 ;
9457   bool result;
9458
9459   argp1 = (Dali::Radian *)jarg1;
9460   if (!argp1) {
9461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9462     return 0;
9463   }
9464   arg1 = *argp1;
9465   argp2 = (Dali::Degree *)jarg2;
9466   if (!argp2) {
9467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9468     return 0;
9469   }
9470   arg2 = *argp2;
9471   {
9472     try {
9473       result = (bool)Dali::operator >(arg1,arg2);
9474     } catch (std::out_of_range& e) {
9475       {
9476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9477       };
9478     } catch (std::exception& e) {
9479       {
9480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9481       };
9482     } catch (...) {
9483       {
9484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9485       };
9486     }
9487   }
9488   jresult = result;
9489   return jresult;
9490 }
9491
9492
9493 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
9494   unsigned int jresult ;
9495   Dali::Degree arg1 ;
9496   Dali::Radian arg2 ;
9497   Dali::Degree *argp1 ;
9498   Dali::Radian *argp2 ;
9499   bool result;
9500
9501   argp1 = (Dali::Degree *)jarg1;
9502   if (!argp1) {
9503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9504     return 0;
9505   }
9506   arg1 = *argp1;
9507   argp2 = (Dali::Radian *)jarg2;
9508   if (!argp2) {
9509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9510     return 0;
9511   }
9512   arg2 = *argp2;
9513   {
9514     try {
9515       result = (bool)Dali::operator >(arg1,arg2);
9516     } catch (std::out_of_range& e) {
9517       {
9518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9519       };
9520     } catch (std::exception& e) {
9521       {
9522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9523       };
9524     } catch (...) {
9525       {
9526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9527       };
9528     }
9529   }
9530   jresult = result;
9531   return jresult;
9532 }
9533
9534
9535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
9536   unsigned int jresult ;
9537   Dali::Radian arg1 ;
9538   Dali::Radian arg2 ;
9539   Dali::Radian *argp1 ;
9540   Dali::Radian *argp2 ;
9541   bool result;
9542
9543   argp1 = (Dali::Radian *)jarg1;
9544   if (!argp1) {
9545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9546     return 0;
9547   }
9548   arg1 = *argp1;
9549   argp2 = (Dali::Radian *)jarg2;
9550   if (!argp2) {
9551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9552     return 0;
9553   }
9554   arg2 = *argp2;
9555   {
9556     try {
9557       result = (bool)Dali::operator <(arg1,arg2);
9558     } catch (std::out_of_range& e) {
9559       {
9560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9561       };
9562     } catch (std::exception& e) {
9563       {
9564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9565       };
9566     } catch (...) {
9567       {
9568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9569       };
9570     }
9571   }
9572   jresult = result;
9573   return jresult;
9574 }
9575
9576
9577 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
9578   unsigned int jresult ;
9579   Dali::Radian arg1 ;
9580   Dali::Degree arg2 ;
9581   Dali::Radian *argp1 ;
9582   Dali::Degree *argp2 ;
9583   bool result;
9584
9585   argp1 = (Dali::Radian *)jarg1;
9586   if (!argp1) {
9587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9588     return 0;
9589   }
9590   arg1 = *argp1;
9591   argp2 = (Dali::Degree *)jarg2;
9592   if (!argp2) {
9593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9594     return 0;
9595   }
9596   arg2 = *argp2;
9597   {
9598     try {
9599       result = (bool)Dali::operator <(arg1,arg2);
9600     } catch (std::out_of_range& e) {
9601       {
9602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9603       };
9604     } catch (std::exception& e) {
9605       {
9606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9607       };
9608     } catch (...) {
9609       {
9610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9611       };
9612     }
9613   }
9614   jresult = result;
9615   return jresult;
9616 }
9617
9618
9619 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
9620   unsigned int jresult ;
9621   Dali::Degree arg1 ;
9622   Dali::Radian arg2 ;
9623   Dali::Degree *argp1 ;
9624   Dali::Radian *argp2 ;
9625   bool result;
9626
9627   argp1 = (Dali::Degree *)jarg1;
9628   if (!argp1) {
9629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9630     return 0;
9631   }
9632   arg1 = *argp1;
9633   argp2 = (Dali::Radian *)jarg2;
9634   if (!argp2) {
9635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9636     return 0;
9637   }
9638   arg2 = *argp2;
9639   {
9640     try {
9641       result = (bool)Dali::operator <(arg1,arg2);
9642     } catch (std::out_of_range& e) {
9643       {
9644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9645       };
9646     } catch (std::exception& e) {
9647       {
9648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9649       };
9650     } catch (...) {
9651       {
9652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9653       };
9654     }
9655   }
9656   jresult = result;
9657   return jresult;
9658 }
9659
9660
9661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
9662   void * jresult ;
9663   Dali::Radian arg1 ;
9664   float arg2 ;
9665   Dali::Radian *argp1 ;
9666   Dali::Radian result;
9667
9668   argp1 = (Dali::Radian *)jarg1;
9669   if (!argp1) {
9670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9671     return 0;
9672   }
9673   arg1 = *argp1;
9674   arg2 = (float)jarg2;
9675   {
9676     try {
9677       result = Dali::operator *(arg1,arg2);
9678     } catch (std::out_of_range& e) {
9679       {
9680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9681       };
9682     } catch (std::exception& e) {
9683       {
9684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9685       };
9686     } catch (...) {
9687       {
9688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9689       };
9690     }
9691   }
9692   jresult = new Dali::Radian((const Dali::Radian &)result);
9693   return jresult;
9694 }
9695
9696
9697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
9698   void * jresult ;
9699   Dali::Radian arg1 ;
9700   Dali::Radian *argp1 ;
9701   Dali::Radian result;
9702
9703   argp1 = (Dali::Radian *)jarg1;
9704   if (!argp1) {
9705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9706     return 0;
9707   }
9708   arg1 = *argp1;
9709   {
9710     try {
9711       result = Dali::operator -(arg1);
9712     } catch (std::out_of_range& e) {
9713       {
9714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9715       };
9716     } catch (std::exception& e) {
9717       {
9718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9719       };
9720     } catch (...) {
9721       {
9722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9723       };
9724     }
9725   }
9726   jresult = new Dali::Radian((const Dali::Radian &)result);
9727   return jresult;
9728 }
9729
9730
9731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
9732   void * jresult ;
9733   Dali::Radian arg1 ;
9734   float arg2 ;
9735   float arg3 ;
9736   Dali::Radian *argp1 ;
9737   Dali::Radian result;
9738
9739   argp1 = (Dali::Radian *)jarg1;
9740   if (!argp1) {
9741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9742     return 0;
9743   }
9744   arg1 = *argp1;
9745   arg2 = (float)jarg2;
9746   arg3 = (float)jarg3;
9747   {
9748     try {
9749       result = Dali::Clamp(arg1,arg2,arg3);
9750     } catch (std::out_of_range& e) {
9751       {
9752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9753       };
9754     } catch (std::exception& e) {
9755       {
9756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9757       };
9758     } catch (...) {
9759       {
9760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9761       };
9762     }
9763   }
9764   jresult = new Dali::Radian((const Dali::Radian &)result);
9765   return jresult;
9766 }
9767
9768
9769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
9770   void * jresult ;
9771   Dali::Quaternion *result = 0 ;
9772
9773   {
9774     try {
9775       result = (Dali::Quaternion *)new Dali::Quaternion();
9776     } catch (std::out_of_range& e) {
9777       {
9778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9779       };
9780     } catch (std::exception& e) {
9781       {
9782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9783       };
9784     } catch (...) {
9785       {
9786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9787       };
9788     }
9789   }
9790   jresult = (void *)result;
9791   return jresult;
9792 }
9793
9794
9795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
9796   void * jresult ;
9797   Dali::Radian arg1 ;
9798   Dali::Vector3 *arg2 = 0 ;
9799   Dali::Radian *argp1 ;
9800   Dali::Quaternion *result = 0 ;
9801
9802   argp1 = (Dali::Radian *)jarg1;
9803   if (!argp1) {
9804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9805     return 0;
9806   }
9807   arg1 = *argp1;
9808   arg2 = (Dali::Vector3 *)jarg2;
9809   if (!arg2) {
9810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9811     return 0;
9812   }
9813   {
9814     try {
9815       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
9816     } catch (std::out_of_range& e) {
9817       {
9818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9819       };
9820     } catch (std::exception& e) {
9821       {
9822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9823       };
9824     } catch (...) {
9825       {
9826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9827       };
9828     }
9829   }
9830   jresult = (void *)result;
9831   return jresult;
9832 }
9833
9834
9835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
9836   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9837
9838   arg1 = (Dali::Quaternion *)jarg1;
9839   {
9840     try {
9841       delete arg1;
9842     } catch (std::out_of_range& e) {
9843       {
9844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9845       };
9846     } catch (std::exception& e) {
9847       {
9848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9849       };
9850     } catch (...) {
9851       {
9852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9853       };
9854     }
9855   }
9856 }
9857
9858
9859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
9860   void * jresult ;
9861   Dali::Quaternion *result = 0 ;
9862
9863   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
9864   jresult = (void *)result;
9865   return jresult;
9866 }
9867
9868
9869 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
9870   unsigned int jresult ;
9871   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9872   bool result;
9873
9874   arg1 = (Dali::Quaternion *)jarg1;
9875   {
9876     try {
9877       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
9878     } catch (std::out_of_range& e) {
9879       {
9880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9881       };
9882     } catch (std::exception& e) {
9883       {
9884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9885       };
9886     } catch (...) {
9887       {
9888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9889       };
9890     }
9891   }
9892   jresult = result;
9893   return jresult;
9894 }
9895
9896
9897 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
9898   unsigned int jresult ;
9899   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9900   Dali::Vector3 *arg2 = 0 ;
9901   Dali::Radian *arg3 = 0 ;
9902   bool result;
9903
9904   arg1 = (Dali::Quaternion *)jarg1;
9905   arg2 = (Dali::Vector3 *)jarg2;
9906   if (!arg2) {
9907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
9908     return 0;
9909   }
9910   arg3 = (Dali::Radian *)jarg3;
9911   if (!arg3) {
9912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
9913     return 0;
9914   }
9915   {
9916     try {
9917       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
9918     } catch (std::out_of_range& e) {
9919       {
9920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9921       };
9922     } catch (std::exception& e) {
9923       {
9924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9925       };
9926     } catch (...) {
9927       {
9928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9929       };
9930     }
9931   }
9932   jresult = result;
9933   return jresult;
9934 }
9935
9936
9937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
9938   void * jresult ;
9939   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9940   Dali::Quaternion *arg2 = 0 ;
9941   Dali::Quaternion result;
9942
9943   arg1 = (Dali::Quaternion *)jarg1;
9944   arg2 = (Dali::Quaternion *)jarg2;
9945   if (!arg2) {
9946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9947     return 0;
9948   }
9949   {
9950     try {
9951       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
9952     } catch (std::out_of_range& e) {
9953       {
9954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9955       };
9956     } catch (std::exception& e) {
9957       {
9958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9959       };
9960     } catch (...) {
9961       {
9962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9963       };
9964     }
9965   }
9966   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9967   return jresult;
9968 }
9969
9970
9971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
9972   void * jresult ;
9973   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9974   Dali::Quaternion *arg2 = 0 ;
9975   Dali::Quaternion result;
9976
9977   arg1 = (Dali::Quaternion *)jarg1;
9978   arg2 = (Dali::Quaternion *)jarg2;
9979   if (!arg2) {
9980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9981     return 0;
9982   }
9983   {
9984     try {
9985       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
9986     } catch (std::out_of_range& e) {
9987       {
9988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9989       };
9990     } catch (std::exception& e) {
9991       {
9992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9993       };
9994     } catch (...) {
9995       {
9996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9997       };
9998     }
9999   }
10000   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10001   return jresult;
10002 }
10003
10004
10005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
10006   void * jresult ;
10007   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10008   Dali::Quaternion *arg2 = 0 ;
10009   Dali::Quaternion result;
10010
10011   arg1 = (Dali::Quaternion *)jarg1;
10012   arg2 = (Dali::Quaternion *)jarg2;
10013   if (!arg2) {
10014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10015     return 0;
10016   }
10017   {
10018     try {
10019       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
10020     } catch (std::out_of_range& e) {
10021       {
10022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10023       };
10024     } catch (std::exception& e) {
10025       {
10026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10027       };
10028     } catch (...) {
10029       {
10030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10031       };
10032     }
10033   }
10034   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10035   return jresult;
10036 }
10037
10038
10039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
10040   void * jresult ;
10041   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10042   Dali::Vector3 *arg2 = 0 ;
10043   Dali::Vector3 result;
10044
10045   arg1 = (Dali::Quaternion *)jarg1;
10046   arg2 = (Dali::Vector3 *)jarg2;
10047   if (!arg2) {
10048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10049     return 0;
10050   }
10051   {
10052     try {
10053       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
10054     } catch (std::out_of_range& e) {
10055       {
10056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10057       };
10058     } catch (std::exception& e) {
10059       {
10060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10061       };
10062     } catch (...) {
10063       {
10064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10065       };
10066     }
10067   }
10068   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
10069   return jresult;
10070 }
10071
10072
10073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
10074   void * jresult ;
10075   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10076   Dali::Quaternion *arg2 = 0 ;
10077   Dali::Quaternion result;
10078
10079   arg1 = (Dali::Quaternion *)jarg1;
10080   arg2 = (Dali::Quaternion *)jarg2;
10081   if (!arg2) {
10082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10083     return 0;
10084   }
10085   {
10086     try {
10087       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
10088     } catch (std::out_of_range& e) {
10089       {
10090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10091       };
10092     } catch (std::exception& e) {
10093       {
10094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10095       };
10096     } catch (...) {
10097       {
10098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10099       };
10100     }
10101   }
10102   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10103   return jresult;
10104 }
10105
10106
10107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
10108   void * jresult ;
10109   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10110   float arg2 ;
10111   Dali::Quaternion result;
10112
10113   arg1 = (Dali::Quaternion *)jarg1;
10114   arg2 = (float)jarg2;
10115   {
10116     try {
10117       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
10118     } catch (std::out_of_range& e) {
10119       {
10120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10121       };
10122     } catch (std::exception& e) {
10123       {
10124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10125       };
10126     } catch (...) {
10127       {
10128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10129       };
10130     }
10131   }
10132   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10133   return jresult;
10134 }
10135
10136
10137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
10138   void * jresult ;
10139   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10140   float arg2 ;
10141   Dali::Quaternion result;
10142
10143   arg1 = (Dali::Quaternion *)jarg1;
10144   arg2 = (float)jarg2;
10145   {
10146     try {
10147       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
10148     } catch (std::out_of_range& e) {
10149       {
10150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10151       };
10152     } catch (std::exception& e) {
10153       {
10154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10155       };
10156     } catch (...) {
10157       {
10158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10159       };
10160     }
10161   }
10162   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10163   return jresult;
10164 }
10165
10166
10167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
10168   void * jresult ;
10169   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10170   Dali::Quaternion result;
10171
10172   arg1 = (Dali::Quaternion *)jarg1;
10173   {
10174     try {
10175       result = ((Dali::Quaternion const *)arg1)->operator -();
10176     } catch (std::out_of_range& e) {
10177       {
10178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10179       };
10180     } catch (std::exception& e) {
10181       {
10182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10183       };
10184     } catch (...) {
10185       {
10186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10187       };
10188     }
10189   }
10190   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10191   return jresult;
10192 }
10193
10194
10195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
10196   void * jresult ;
10197   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10198   Dali::Quaternion *arg2 = 0 ;
10199   Dali::Quaternion *result = 0 ;
10200
10201   arg1 = (Dali::Quaternion *)jarg1;
10202   arg2 = (Dali::Quaternion *)jarg2;
10203   if (!arg2) {
10204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10205     return 0;
10206   }
10207   {
10208     try {
10209       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
10210     } catch (std::out_of_range& e) {
10211       {
10212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10213       };
10214     } catch (std::exception& e) {
10215       {
10216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10217       };
10218     } catch (...) {
10219       {
10220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10221       };
10222     }
10223   }
10224   jresult = (void *)result;
10225   return jresult;
10226 }
10227
10228
10229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
10230   void * jresult ;
10231   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10232   Dali::Quaternion *arg2 = 0 ;
10233   Dali::Quaternion *result = 0 ;
10234
10235   arg1 = (Dali::Quaternion *)jarg1;
10236   arg2 = (Dali::Quaternion *)jarg2;
10237   if (!arg2) {
10238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10239     return 0;
10240   }
10241   {
10242     try {
10243       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
10244     } catch (std::out_of_range& e) {
10245       {
10246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10247       };
10248     } catch (std::exception& e) {
10249       {
10250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10251       };
10252     } catch (...) {
10253       {
10254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10255       };
10256     }
10257   }
10258   jresult = (void *)result;
10259   return jresult;
10260 }
10261
10262
10263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
10264   void * jresult ;
10265   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10266   Dali::Quaternion *arg2 = 0 ;
10267   Dali::Quaternion *result = 0 ;
10268
10269   arg1 = (Dali::Quaternion *)jarg1;
10270   arg2 = (Dali::Quaternion *)jarg2;
10271   if (!arg2) {
10272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10273     return 0;
10274   }
10275   {
10276     try {
10277       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
10278     } catch (std::out_of_range& e) {
10279       {
10280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10281       };
10282     } catch (std::exception& e) {
10283       {
10284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10285       };
10286     } catch (...) {
10287       {
10288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10289       };
10290     }
10291   }
10292   jresult = (void *)result;
10293   return jresult;
10294 }
10295
10296
10297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
10298   void * jresult ;
10299   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10300   float arg2 ;
10301   Dali::Quaternion *result = 0 ;
10302
10303   arg1 = (Dali::Quaternion *)jarg1;
10304   arg2 = (float)jarg2;
10305   {
10306     try {
10307       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
10308     } catch (std::out_of_range& e) {
10309       {
10310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10311       };
10312     } catch (std::exception& e) {
10313       {
10314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10315       };
10316     } catch (...) {
10317       {
10318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10319       };
10320     }
10321   }
10322   jresult = (void *)result;
10323   return jresult;
10324 }
10325
10326
10327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
10328   void * jresult ;
10329   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10330   float arg2 ;
10331   Dali::Quaternion *result = 0 ;
10332
10333   arg1 = (Dali::Quaternion *)jarg1;
10334   arg2 = (float)jarg2;
10335   {
10336     try {
10337       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
10338     } catch (std::out_of_range& e) {
10339       {
10340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10341       };
10342     } catch (std::exception& e) {
10343       {
10344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10345       };
10346     } catch (...) {
10347       {
10348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10349       };
10350     }
10351   }
10352   jresult = (void *)result;
10353   return jresult;
10354 }
10355
10356
10357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
10358   unsigned int jresult ;
10359   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10360   Dali::Quaternion *arg2 = 0 ;
10361   bool result;
10362
10363   arg1 = (Dali::Quaternion *)jarg1;
10364   arg2 = (Dali::Quaternion *)jarg2;
10365   if (!arg2) {
10366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10367     return 0;
10368   }
10369   {
10370     try {
10371       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
10372     } catch (std::out_of_range& e) {
10373       {
10374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10375       };
10376     } catch (std::exception& e) {
10377       {
10378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10379       };
10380     } catch (...) {
10381       {
10382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10383       };
10384     }
10385   }
10386   jresult = result;
10387   return jresult;
10388 }
10389
10390
10391 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
10392   unsigned int jresult ;
10393   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10394   Dali::Quaternion *arg2 = 0 ;
10395   bool result;
10396
10397   arg1 = (Dali::Quaternion *)jarg1;
10398   arg2 = (Dali::Quaternion *)jarg2;
10399   if (!arg2) {
10400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10401     return 0;
10402   }
10403   {
10404     try {
10405       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
10406     } catch (std::out_of_range& e) {
10407       {
10408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10409       };
10410     } catch (std::exception& e) {
10411       {
10412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10413       };
10414     } catch (...) {
10415       {
10416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10417       };
10418     }
10419   }
10420   jresult = result;
10421   return jresult;
10422 }
10423
10424
10425 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
10426   float jresult ;
10427   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10428   float result;
10429
10430   arg1 = (Dali::Quaternion *)jarg1;
10431   {
10432     try {
10433       result = (float)((Dali::Quaternion const *)arg1)->Length();
10434     } catch (std::out_of_range& e) {
10435       {
10436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10437       };
10438     } catch (std::exception& e) {
10439       {
10440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10441       };
10442     } catch (...) {
10443       {
10444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10445       };
10446     }
10447   }
10448   jresult = result;
10449   return jresult;
10450 }
10451
10452
10453 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
10454   float jresult ;
10455   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10456   float result;
10457
10458   arg1 = (Dali::Quaternion *)jarg1;
10459   {
10460     try {
10461       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
10462     } catch (std::out_of_range& e) {
10463       {
10464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10465       };
10466     } catch (std::exception& e) {
10467       {
10468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10469       };
10470     } catch (...) {
10471       {
10472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10473       };
10474     }
10475   }
10476   jresult = result;
10477   return jresult;
10478 }
10479
10480
10481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
10482   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10483
10484   arg1 = (Dali::Quaternion *)jarg1;
10485   {
10486     try {
10487       (arg1)->Normalize();
10488     } catch (std::out_of_range& e) {
10489       {
10490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10491       };
10492     } catch (std::exception& e) {
10493       {
10494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10495       };
10496     } catch (...) {
10497       {
10498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10499       };
10500     }
10501   }
10502 }
10503
10504
10505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
10506   void * jresult ;
10507   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10508   Dali::Quaternion result;
10509
10510   arg1 = (Dali::Quaternion *)jarg1;
10511   {
10512     try {
10513       result = ((Dali::Quaternion const *)arg1)->Normalized();
10514     } catch (std::out_of_range& e) {
10515       {
10516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10517       };
10518     } catch (std::exception& e) {
10519       {
10520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10521       };
10522     } catch (...) {
10523       {
10524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10525       };
10526     }
10527   }
10528   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10529   return jresult;
10530 }
10531
10532
10533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
10534   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10535
10536   arg1 = (Dali::Quaternion *)jarg1;
10537   {
10538     try {
10539       (arg1)->Conjugate();
10540     } catch (std::out_of_range& e) {
10541       {
10542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10543       };
10544     } catch (std::exception& e) {
10545       {
10546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10547       };
10548     } catch (...) {
10549       {
10550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10551       };
10552     }
10553   }
10554 }
10555
10556
10557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
10558   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10559
10560   arg1 = (Dali::Quaternion *)jarg1;
10561   {
10562     try {
10563       (arg1)->Invert();
10564     } catch (std::out_of_range& e) {
10565       {
10566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10567       };
10568     } catch (std::exception& e) {
10569       {
10570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10571       };
10572     } catch (...) {
10573       {
10574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10575       };
10576     }
10577   }
10578 }
10579
10580
10581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
10582   void * jresult ;
10583   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10584   Dali::Quaternion result;
10585
10586   arg1 = (Dali::Quaternion *)jarg1;
10587   {
10588     try {
10589       result = ((Dali::Quaternion const *)arg1)->Log();
10590     } catch (std::out_of_range& e) {
10591       {
10592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10593       };
10594     } catch (std::exception& e) {
10595       {
10596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10597       };
10598     } catch (...) {
10599       {
10600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10601       };
10602     }
10603   }
10604   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10605   return jresult;
10606 }
10607
10608
10609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
10610   void * jresult ;
10611   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10612   Dali::Quaternion result;
10613
10614   arg1 = (Dali::Quaternion *)jarg1;
10615   {
10616     try {
10617       result = ((Dali::Quaternion const *)arg1)->Exp();
10618     } catch (std::out_of_range& e) {
10619       {
10620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10621       };
10622     } catch (std::exception& e) {
10623       {
10624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10625       };
10626     } catch (...) {
10627       {
10628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10629       };
10630     }
10631   }
10632   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10633   return jresult;
10634 }
10635
10636
10637 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
10638   float jresult ;
10639   Dali::Quaternion *arg1 = 0 ;
10640   Dali::Quaternion *arg2 = 0 ;
10641   float result;
10642
10643   arg1 = (Dali::Quaternion *)jarg1;
10644   if (!arg1) {
10645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10646     return 0;
10647   }
10648   arg2 = (Dali::Quaternion *)jarg2;
10649   if (!arg2) {
10650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10651     return 0;
10652   }
10653   {
10654     try {
10655       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10656     } catch (std::out_of_range& e) {
10657       {
10658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10659       };
10660     } catch (std::exception& e) {
10661       {
10662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10663       };
10664     } catch (...) {
10665       {
10666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10667       };
10668     }
10669   }
10670   jresult = result;
10671   return jresult;
10672 }
10673
10674
10675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
10676   void * jresult ;
10677   Dali::Quaternion *arg1 = 0 ;
10678   Dali::Quaternion *arg2 = 0 ;
10679   float arg3 ;
10680   Dali::Quaternion result;
10681
10682   arg1 = (Dali::Quaternion *)jarg1;
10683   if (!arg1) {
10684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10685     return 0;
10686   }
10687   arg2 = (Dali::Quaternion *)jarg2;
10688   if (!arg2) {
10689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10690     return 0;
10691   }
10692   arg3 = (float)jarg3;
10693   {
10694     try {
10695       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10696     } catch (std::out_of_range& e) {
10697       {
10698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10699       };
10700     } catch (std::exception& e) {
10701       {
10702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10703       };
10704     } catch (...) {
10705       {
10706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10707       };
10708     }
10709   }
10710   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10711   return jresult;
10712 }
10713
10714
10715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
10716   void * jresult ;
10717   Dali::Quaternion *arg1 = 0 ;
10718   Dali::Quaternion *arg2 = 0 ;
10719   float arg3 ;
10720   Dali::Quaternion result;
10721
10722   arg1 = (Dali::Quaternion *)jarg1;
10723   if (!arg1) {
10724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10725     return 0;
10726   }
10727   arg2 = (Dali::Quaternion *)jarg2;
10728   if (!arg2) {
10729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10730     return 0;
10731   }
10732   arg3 = (float)jarg3;
10733   {
10734     try {
10735       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10736     } catch (std::out_of_range& e) {
10737       {
10738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10739       };
10740     } catch (std::exception& e) {
10741       {
10742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10743       };
10744     } catch (...) {
10745       {
10746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10747       };
10748     }
10749   }
10750   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10751   return jresult;
10752 }
10753
10754
10755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
10756   void * jresult ;
10757   Dali::Quaternion *arg1 = 0 ;
10758   Dali::Quaternion *arg2 = 0 ;
10759   float arg3 ;
10760   Dali::Quaternion result;
10761
10762   arg1 = (Dali::Quaternion *)jarg1;
10763   if (!arg1) {
10764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10765     return 0;
10766   }
10767   arg2 = (Dali::Quaternion *)jarg2;
10768   if (!arg2) {
10769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10770     return 0;
10771   }
10772   arg3 = (float)jarg3;
10773   {
10774     try {
10775       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10776     } catch (std::out_of_range& e) {
10777       {
10778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10779       };
10780     } catch (std::exception& e) {
10781       {
10782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10783       };
10784     } catch (...) {
10785       {
10786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10787       };
10788     }
10789   }
10790   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10791   return jresult;
10792 }
10793
10794
10795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
10796   void * jresult ;
10797   Dali::Quaternion *arg1 = 0 ;
10798   Dali::Quaternion *arg2 = 0 ;
10799   Dali::Quaternion *arg3 = 0 ;
10800   Dali::Quaternion *arg4 = 0 ;
10801   float arg5 ;
10802   Dali::Quaternion result;
10803
10804   arg1 = (Dali::Quaternion *)jarg1;
10805   if (!arg1) {
10806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10807     return 0;
10808   }
10809   arg2 = (Dali::Quaternion *)jarg2;
10810   if (!arg2) {
10811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10812     return 0;
10813   }
10814   arg3 = (Dali::Quaternion *)jarg3;
10815   if (!arg3) {
10816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10817     return 0;
10818   }
10819   arg4 = (Dali::Quaternion *)jarg4;
10820   if (!arg4) {
10821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10822     return 0;
10823   }
10824   arg5 = (float)jarg5;
10825   {
10826     try {
10827       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
10828     } catch (std::out_of_range& e) {
10829       {
10830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10831       };
10832     } catch (std::exception& e) {
10833       {
10834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10835       };
10836     } catch (...) {
10837       {
10838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10839       };
10840     }
10841   }
10842   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10843   return jresult;
10844 }
10845
10846
10847 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
10848   float jresult ;
10849   Dali::Quaternion *arg1 = 0 ;
10850   Dali::Quaternion *arg2 = 0 ;
10851   float result;
10852
10853   arg1 = (Dali::Quaternion *)jarg1;
10854   if (!arg1) {
10855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10856     return 0;
10857   }
10858   arg2 = (Dali::Quaternion *)jarg2;
10859   if (!arg2) {
10860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10861     return 0;
10862   }
10863   {
10864     try {
10865       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10866     } catch (std::out_of_range& e) {
10867       {
10868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10869       };
10870     } catch (std::exception& e) {
10871       {
10872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10873       };
10874     } catch (...) {
10875       {
10876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10877       };
10878     }
10879   }
10880   jresult = result;
10881   return jresult;
10882 }
10883
10884
10885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
10886   void * jresult ;
10887   Dali::Matrix *result = 0 ;
10888
10889   {
10890     try {
10891       result = (Dali::Matrix *)new Dali::Matrix();
10892     } catch (std::out_of_range& e) {
10893       {
10894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10895       };
10896     } catch (std::exception& e) {
10897       {
10898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10899       };
10900     } catch (...) {
10901       {
10902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10903       };
10904     }
10905   }
10906   jresult = (void *)result;
10907   return jresult;
10908 }
10909
10910
10911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
10912   void * jresult ;
10913   bool arg1 ;
10914   Dali::Matrix *result = 0 ;
10915
10916   arg1 = jarg1 ? true : false;
10917   {
10918     try {
10919       result = (Dali::Matrix *)new Dali::Matrix(arg1);
10920     } catch (std::out_of_range& e) {
10921       {
10922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10923       };
10924     } catch (std::exception& e) {
10925       {
10926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10927       };
10928     } catch (...) {
10929       {
10930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10931       };
10932     }
10933   }
10934   jresult = (void *)result;
10935   return jresult;
10936 }
10937
10938
10939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
10940   void * jresult ;
10941   float *arg1 = (float *) 0 ;
10942   Dali::Matrix *result = 0 ;
10943
10944   arg1 = jarg1;
10945   {
10946     try {
10947       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
10948     } catch (std::out_of_range& e) {
10949       {
10950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10951       };
10952     } catch (std::exception& e) {
10953       {
10954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10955       };
10956     } catch (...) {
10957       {
10958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10959       };
10960     }
10961   }
10962   jresult = (void *)result;
10963
10964
10965   return jresult;
10966 }
10967
10968
10969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
10970   void * jresult ;
10971   Dali::Quaternion *arg1 = 0 ;
10972   Dali::Matrix *result = 0 ;
10973
10974   arg1 = (Dali::Quaternion *)jarg1;
10975   if (!arg1) {
10976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10977     return 0;
10978   }
10979   {
10980     try {
10981       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
10982     } catch (std::out_of_range& e) {
10983       {
10984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10985       };
10986     } catch (std::exception& e) {
10987       {
10988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10989       };
10990     } catch (...) {
10991       {
10992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10993       };
10994     }
10995   }
10996   jresult = (void *)result;
10997   return jresult;
10998 }
10999
11000
11001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
11002   void * jresult ;
11003   Dali::Matrix *arg1 = 0 ;
11004   Dali::Matrix *result = 0 ;
11005
11006   arg1 = (Dali::Matrix *)jarg1;
11007   if (!arg1) {
11008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11009     return 0;
11010   }
11011   {
11012     try {
11013       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
11014     } catch (std::out_of_range& e) {
11015       {
11016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11017       };
11018     } catch (std::exception& e) {
11019       {
11020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11021       };
11022     } catch (...) {
11023       {
11024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11025       };
11026     }
11027   }
11028   jresult = (void *)result;
11029   return jresult;
11030 }
11031
11032
11033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
11034   void * jresult ;
11035   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11036   Dali::Matrix *arg2 = 0 ;
11037   Dali::Matrix *result = 0 ;
11038
11039   arg1 = (Dali::Matrix *)jarg1;
11040   arg2 = (Dali::Matrix *)jarg2;
11041   if (!arg2) {
11042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11043     return 0;
11044   }
11045   {
11046     try {
11047       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
11048     } catch (std::out_of_range& e) {
11049       {
11050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11051       };
11052     } catch (std::exception& e) {
11053       {
11054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11055       };
11056     } catch (...) {
11057       {
11058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11059       };
11060     }
11061   }
11062   jresult = (void *)result;
11063   return jresult;
11064 }
11065
11066
11067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
11068   void * jresult ;
11069   Dali::Matrix *result = 0 ;
11070
11071   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
11072   jresult = (void *)result;
11073   return jresult;
11074 }
11075
11076
11077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
11078   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11079
11080   arg1 = (Dali::Matrix *)jarg1;
11081   {
11082     try {
11083       (arg1)->SetIdentity();
11084     } catch (std::out_of_range& e) {
11085       {
11086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11087       };
11088     } catch (std::exception& e) {
11089       {
11090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11091       };
11092     } catch (...) {
11093       {
11094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11095       };
11096     }
11097   }
11098 }
11099
11100
11101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
11102   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11103   Dali::Vector3 *arg2 = 0 ;
11104
11105   arg1 = (Dali::Matrix *)jarg1;
11106   arg2 = (Dali::Vector3 *)jarg2;
11107   if (!arg2) {
11108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11109     return ;
11110   }
11111   {
11112     try {
11113       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
11114     } catch (std::out_of_range& e) {
11115       {
11116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11117       };
11118     } catch (std::exception& e) {
11119       {
11120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11121       };
11122     } catch (...) {
11123       {
11124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11125       };
11126     }
11127   }
11128 }
11129
11130
11131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
11132   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11133   Dali::Matrix *arg2 = 0 ;
11134
11135   arg1 = (Dali::Matrix *)jarg1;
11136   arg2 = (Dali::Matrix *)jarg2;
11137   if (!arg2) {
11138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11139     return ;
11140   }
11141   {
11142     try {
11143       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
11144     } catch (std::out_of_range& e) {
11145       {
11146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11147       };
11148     } catch (std::exception& e) {
11149       {
11150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11151       };
11152     } catch (...) {
11153       {
11154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11155       };
11156     }
11157   }
11158 }
11159
11160
11161 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
11162   unsigned int jresult ;
11163   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11164   bool result;
11165
11166   arg1 = (Dali::Matrix *)jarg1;
11167   {
11168     try {
11169       result = (bool)(arg1)->Invert();
11170     } catch (std::out_of_range& e) {
11171       {
11172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11173       };
11174     } catch (std::exception& e) {
11175       {
11176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11177       };
11178     } catch (...) {
11179       {
11180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11181       };
11182     }
11183   }
11184   jresult = result;
11185   return jresult;
11186 }
11187
11188
11189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
11190   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11191
11192   arg1 = (Dali::Matrix *)jarg1;
11193   {
11194     try {
11195       (arg1)->Transpose();
11196     } catch (std::out_of_range& e) {
11197       {
11198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11199       };
11200     } catch (std::exception& e) {
11201       {
11202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11203       };
11204     } catch (...) {
11205       {
11206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11207       };
11208     }
11209   }
11210 }
11211
11212
11213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
11214   void * jresult ;
11215   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11216   Dali::Vector3 result;
11217
11218   arg1 = (Dali::Matrix *)jarg1;
11219   {
11220     try {
11221       result = ((Dali::Matrix const *)arg1)->GetXAxis();
11222     } catch (std::out_of_range& e) {
11223       {
11224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11225       };
11226     } catch (std::exception& e) {
11227       {
11228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11229       };
11230     } catch (...) {
11231       {
11232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11233       };
11234     }
11235   }
11236   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11237   return jresult;
11238 }
11239
11240
11241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
11242   void * jresult ;
11243   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11244   Dali::Vector3 result;
11245
11246   arg1 = (Dali::Matrix *)jarg1;
11247   {
11248     try {
11249       result = ((Dali::Matrix const *)arg1)->GetYAxis();
11250     } catch (std::out_of_range& e) {
11251       {
11252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11253       };
11254     } catch (std::exception& e) {
11255       {
11256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11257       };
11258     } catch (...) {
11259       {
11260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11261       };
11262     }
11263   }
11264   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11265   return jresult;
11266 }
11267
11268
11269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
11270   void * jresult ;
11271   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11272   Dali::Vector3 result;
11273
11274   arg1 = (Dali::Matrix *)jarg1;
11275   {
11276     try {
11277       result = ((Dali::Matrix const *)arg1)->GetZAxis();
11278     } catch (std::out_of_range& e) {
11279       {
11280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11281       };
11282     } catch (std::exception& e) {
11283       {
11284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11285       };
11286     } catch (...) {
11287       {
11288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11289       };
11290     }
11291   }
11292   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11293   return jresult;
11294 }
11295
11296
11297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
11298   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11299   Dali::Vector3 *arg2 = 0 ;
11300
11301   arg1 = (Dali::Matrix *)jarg1;
11302   arg2 = (Dali::Vector3 *)jarg2;
11303   if (!arg2) {
11304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11305     return ;
11306   }
11307   {
11308     try {
11309       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
11310     } catch (std::out_of_range& e) {
11311       {
11312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11313       };
11314     } catch (std::exception& e) {
11315       {
11316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11317       };
11318     } catch (...) {
11319       {
11320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11321       };
11322     }
11323   }
11324 }
11325
11326
11327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
11328   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11329   Dali::Vector3 *arg2 = 0 ;
11330
11331   arg1 = (Dali::Matrix *)jarg1;
11332   arg2 = (Dali::Vector3 *)jarg2;
11333   if (!arg2) {
11334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11335     return ;
11336   }
11337   {
11338     try {
11339       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
11340     } catch (std::out_of_range& e) {
11341       {
11342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11343       };
11344     } catch (std::exception& e) {
11345       {
11346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11347       };
11348     } catch (...) {
11349       {
11350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11351       };
11352     }
11353   }
11354 }
11355
11356
11357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
11358   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11359   Dali::Vector3 *arg2 = 0 ;
11360
11361   arg1 = (Dali::Matrix *)jarg1;
11362   arg2 = (Dali::Vector3 *)jarg2;
11363   if (!arg2) {
11364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11365     return ;
11366   }
11367   {
11368     try {
11369       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
11370     } catch (std::out_of_range& e) {
11371       {
11372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11373       };
11374     } catch (std::exception& e) {
11375       {
11376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11377       };
11378     } catch (...) {
11379       {
11380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11381       };
11382     }
11383   }
11384 }
11385
11386
11387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
11388   void * jresult ;
11389   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11390   Dali::Vector4 *result = 0 ;
11391
11392   arg1 = (Dali::Matrix *)jarg1;
11393   {
11394     try {
11395       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
11396     } catch (std::out_of_range& e) {
11397       {
11398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11399       };
11400     } catch (std::exception& e) {
11401       {
11402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11403       };
11404     } catch (...) {
11405       {
11406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11407       };
11408     }
11409   }
11410   jresult = (void *)result;
11411   return jresult;
11412 }
11413
11414
11415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
11416   void * jresult ;
11417   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11418   Dali::Vector3 *result = 0 ;
11419
11420   arg1 = (Dali::Matrix *)jarg1;
11421   {
11422     try {
11423       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
11424     } catch (std::out_of_range& e) {
11425       {
11426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11427       };
11428     } catch (std::exception& e) {
11429       {
11430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11431       };
11432     } catch (...) {
11433       {
11434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11435       };
11436     }
11437   }
11438   jresult = (void *)result;
11439   return jresult;
11440 }
11441
11442
11443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
11444   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11445   Dali::Vector4 *arg2 = 0 ;
11446
11447   arg1 = (Dali::Matrix *)jarg1;
11448   arg2 = (Dali::Vector4 *)jarg2;
11449   if (!arg2) {
11450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11451     return ;
11452   }
11453   {
11454     try {
11455       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
11456     } catch (std::out_of_range& e) {
11457       {
11458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11459       };
11460     } catch (std::exception& e) {
11461       {
11462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11463       };
11464     } catch (...) {
11465       {
11466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11467       };
11468     }
11469   }
11470 }
11471
11472
11473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
11474   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11475   Dali::Vector3 *arg2 = 0 ;
11476
11477   arg1 = (Dali::Matrix *)jarg1;
11478   arg2 = (Dali::Vector3 *)jarg2;
11479   if (!arg2) {
11480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11481     return ;
11482   }
11483   {
11484     try {
11485       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
11486     } catch (std::out_of_range& e) {
11487       {
11488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11489       };
11490     } catch (std::exception& e) {
11491       {
11492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11493       };
11494     } catch (...) {
11495       {
11496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11497       };
11498     }
11499   }
11500 }
11501
11502
11503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
11504   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11505
11506   arg1 = (Dali::Matrix *)jarg1;
11507   {
11508     try {
11509       (arg1)->OrthoNormalize();
11510     } catch (std::out_of_range& e) {
11511       {
11512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11513       };
11514     } catch (std::exception& e) {
11515       {
11516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11517       };
11518     } catch (...) {
11519       {
11520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11521       };
11522     }
11523   }
11524 }
11525
11526
11527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
11528   void * jresult ;
11529   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11530   float *result = 0 ;
11531
11532   arg1 = (Dali::Matrix *)jarg1;
11533   {
11534     try {
11535       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
11536     } catch (std::out_of_range& e) {
11537       {
11538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11539       };
11540     } catch (std::exception& e) {
11541       {
11542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11543       };
11544     } catch (...) {
11545       {
11546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11547       };
11548     }
11549   }
11550   jresult = (void *)result;
11551   return jresult;
11552 }
11553
11554
11555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
11556   Dali::Matrix *arg1 = 0 ;
11557   Dali::Matrix *arg2 = 0 ;
11558   Dali::Matrix *arg3 = 0 ;
11559
11560   arg1 = (Dali::Matrix *)jarg1;
11561   if (!arg1) {
11562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11563     return ;
11564   }
11565   arg2 = (Dali::Matrix *)jarg2;
11566   if (!arg2) {
11567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11568     return ;
11569   }
11570   arg3 = (Dali::Matrix *)jarg3;
11571   if (!arg3) {
11572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11573     return ;
11574   }
11575   {
11576     try {
11577       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
11578     } catch (std::out_of_range& e) {
11579       {
11580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11581       };
11582     } catch (std::exception& e) {
11583       {
11584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11585       };
11586     } catch (...) {
11587       {
11588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11589       };
11590     }
11591   }
11592 }
11593
11594
11595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
11596   Dali::Matrix *arg1 = 0 ;
11597   Dali::Matrix *arg2 = 0 ;
11598   Dali::Quaternion *arg3 = 0 ;
11599
11600   arg1 = (Dali::Matrix *)jarg1;
11601   if (!arg1) {
11602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11603     return ;
11604   }
11605   arg2 = (Dali::Matrix *)jarg2;
11606   if (!arg2) {
11607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11608     return ;
11609   }
11610   arg3 = (Dali::Quaternion *)jarg3;
11611   if (!arg3) {
11612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11613     return ;
11614   }
11615   {
11616     try {
11617       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
11618     } catch (std::out_of_range& e) {
11619       {
11620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11621       };
11622     } catch (std::exception& e) {
11623       {
11624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11625       };
11626     } catch (...) {
11627       {
11628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11629       };
11630     }
11631   }
11632 }
11633
11634
11635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
11636   void * jresult ;
11637   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11638   Dali::Vector4 *arg2 = 0 ;
11639   Dali::Vector4 result;
11640
11641   arg1 = (Dali::Matrix *)jarg1;
11642   arg2 = (Dali::Vector4 *)jarg2;
11643   if (!arg2) {
11644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11645     return 0;
11646   }
11647   {
11648     try {
11649       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
11650     } catch (std::out_of_range& e) {
11651       {
11652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11653       };
11654     } catch (std::exception& e) {
11655       {
11656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11657       };
11658     } catch (...) {
11659       {
11660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11661       };
11662     }
11663   }
11664   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
11665   return jresult;
11666 }
11667
11668
11669 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
11670   unsigned int jresult ;
11671   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11672   Dali::Matrix *arg2 = 0 ;
11673   bool result;
11674
11675   arg1 = (Dali::Matrix *)jarg1;
11676   arg2 = (Dali::Matrix *)jarg2;
11677   if (!arg2) {
11678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11679     return 0;
11680   }
11681   {
11682     try {
11683       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
11684     } catch (std::out_of_range& e) {
11685       {
11686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11687       };
11688     } catch (std::exception& e) {
11689       {
11690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11691       };
11692     } catch (...) {
11693       {
11694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11695       };
11696     }
11697   }
11698   jresult = result;
11699   return jresult;
11700 }
11701
11702
11703 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
11704   unsigned int jresult ;
11705   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11706   Dali::Matrix *arg2 = 0 ;
11707   bool result;
11708
11709   arg1 = (Dali::Matrix *)jarg1;
11710   arg2 = (Dali::Matrix *)jarg2;
11711   if (!arg2) {
11712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11713     return 0;
11714   }
11715   {
11716     try {
11717       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
11718     } catch (std::out_of_range& e) {
11719       {
11720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11721       };
11722     } catch (std::exception& e) {
11723       {
11724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11725       };
11726     } catch (...) {
11727       {
11728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11729       };
11730     }
11731   }
11732   jresult = result;
11733   return jresult;
11734 }
11735
11736
11737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11738   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11739   Dali::Vector3 *arg2 = 0 ;
11740   Dali::Quaternion *arg3 = 0 ;
11741   Dali::Vector3 *arg4 = 0 ;
11742
11743   arg1 = (Dali::Matrix *)jarg1;
11744   arg2 = (Dali::Vector3 *)jarg2;
11745   if (!arg2) {
11746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11747     return ;
11748   }
11749   arg3 = (Dali::Quaternion *)jarg3;
11750   if (!arg3) {
11751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11752     return ;
11753   }
11754   arg4 = (Dali::Vector3 *)jarg4;
11755   if (!arg4) {
11756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11757     return ;
11758   }
11759   {
11760     try {
11761       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11762     } catch (std::out_of_range& e) {
11763       {
11764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11765       };
11766     } catch (std::exception& e) {
11767       {
11768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11769       };
11770     } catch (...) {
11771       {
11772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11773       };
11774     }
11775   }
11776 }
11777
11778
11779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11780   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11781   Dali::Vector3 *arg2 = 0 ;
11782   Dali::Quaternion *arg3 = 0 ;
11783   Dali::Vector3 *arg4 = 0 ;
11784
11785   arg1 = (Dali::Matrix *)jarg1;
11786   arg2 = (Dali::Vector3 *)jarg2;
11787   if (!arg2) {
11788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11789     return ;
11790   }
11791   arg3 = (Dali::Quaternion *)jarg3;
11792   if (!arg3) {
11793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11794     return ;
11795   }
11796   arg4 = (Dali::Vector3 *)jarg4;
11797   if (!arg4) {
11798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11799     return ;
11800   }
11801   {
11802     try {
11803       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11804     } catch (std::out_of_range& e) {
11805       {
11806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11807       };
11808     } catch (std::exception& e) {
11809       {
11810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11811       };
11812     } catch (...) {
11813       {
11814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11815       };
11816     }
11817   }
11818 }
11819
11820
11821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
11822   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11823   Dali::Vector3 *arg2 = 0 ;
11824   Dali::Vector3 *arg3 = 0 ;
11825   Dali::Vector3 *arg4 = 0 ;
11826   Dali::Vector3 *arg5 = 0 ;
11827
11828   arg1 = (Dali::Matrix *)jarg1;
11829   arg2 = (Dali::Vector3 *)jarg2;
11830   if (!arg2) {
11831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11832     return ;
11833   }
11834   arg3 = (Dali::Vector3 *)jarg3;
11835   if (!arg3) {
11836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11837     return ;
11838   }
11839   arg4 = (Dali::Vector3 *)jarg4;
11840   if (!arg4) {
11841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11842     return ;
11843   }
11844   arg5 = (Dali::Vector3 *)jarg5;
11845   if (!arg5) {
11846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11847     return ;
11848   }
11849   {
11850     try {
11851       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
11852     } catch (std::out_of_range& e) {
11853       {
11854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11855       };
11856     } catch (std::exception& e) {
11857       {
11858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11859       };
11860     } catch (...) {
11861       {
11862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11863       };
11864     }
11865   }
11866 }
11867
11868
11869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11870   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11871   Dali::Vector3 *arg2 = 0 ;
11872   Dali::Quaternion *arg3 = 0 ;
11873   Dali::Vector3 *arg4 = 0 ;
11874
11875   arg1 = (Dali::Matrix *)jarg1;
11876   arg2 = (Dali::Vector3 *)jarg2;
11877   if (!arg2) {
11878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11879     return ;
11880   }
11881   arg3 = (Dali::Quaternion *)jarg3;
11882   if (!arg3) {
11883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
11884     return ;
11885   }
11886   arg4 = (Dali::Vector3 *)jarg4;
11887   if (!arg4) {
11888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11889     return ;
11890   }
11891   {
11892     try {
11893       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
11894     } catch (std::out_of_range& e) {
11895       {
11896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11897       };
11898     } catch (std::exception& e) {
11899       {
11900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11901       };
11902     } catch (...) {
11903       {
11904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11905       };
11906     }
11907   }
11908 }
11909
11910
11911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
11912   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11913
11914   arg1 = (Dali::Matrix *)jarg1;
11915   {
11916     try {
11917       delete arg1;
11918     } catch (std::out_of_range& e) {
11919       {
11920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11921       };
11922     } catch (std::exception& e) {
11923       {
11924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11925       };
11926     } catch (...) {
11927       {
11928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11929       };
11930     }
11931   }
11932 }
11933
11934
11935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
11936   void * jresult ;
11937   Dali::Matrix3 *result = 0 ;
11938
11939   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
11940   jresult = (void *)result;
11941   return jresult;
11942 }
11943
11944
11945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
11946   void * jresult ;
11947   Dali::Matrix3 *result = 0 ;
11948
11949   {
11950     try {
11951       result = (Dali::Matrix3 *)new Dali::Matrix3();
11952     } catch (std::out_of_range& e) {
11953       {
11954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11955       };
11956     } catch (std::exception& e) {
11957       {
11958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11959       };
11960     } catch (...) {
11961       {
11962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11963       };
11964     }
11965   }
11966   jresult = (void *)result;
11967   return jresult;
11968 }
11969
11970
11971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
11972   void * jresult ;
11973   Dali::Matrix3 *arg1 = 0 ;
11974   Dali::Matrix3 *result = 0 ;
11975
11976   arg1 = (Dali::Matrix3 *)jarg1;
11977   if (!arg1) {
11978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
11979     return 0;
11980   }
11981   {
11982     try {
11983       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
11984     } catch (std::out_of_range& e) {
11985       {
11986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11987       };
11988     } catch (std::exception& e) {
11989       {
11990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11991       };
11992     } catch (...) {
11993       {
11994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11995       };
11996     }
11997   }
11998   jresult = (void *)result;
11999   return jresult;
12000 }
12001
12002
12003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
12004   void * jresult ;
12005   Dali::Matrix *arg1 = 0 ;
12006   Dali::Matrix3 *result = 0 ;
12007
12008   arg1 = (Dali::Matrix *)jarg1;
12009   if (!arg1) {
12010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12011     return 0;
12012   }
12013   {
12014     try {
12015       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
12016     } catch (std::out_of_range& e) {
12017       {
12018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12019       };
12020     } catch (std::exception& e) {
12021       {
12022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12023       };
12024     } catch (...) {
12025       {
12026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12027       };
12028     }
12029   }
12030   jresult = (void *)result;
12031   return jresult;
12032 }
12033
12034
12035 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) {
12036   void * jresult ;
12037   float arg1 ;
12038   float arg2 ;
12039   float arg3 ;
12040   float arg4 ;
12041   float arg5 ;
12042   float arg6 ;
12043   float arg7 ;
12044   float arg8 ;
12045   float arg9 ;
12046   Dali::Matrix3 *result = 0 ;
12047
12048   arg1 = (float)jarg1;
12049   arg2 = (float)jarg2;
12050   arg3 = (float)jarg3;
12051   arg4 = (float)jarg4;
12052   arg5 = (float)jarg5;
12053   arg6 = (float)jarg6;
12054   arg7 = (float)jarg7;
12055   arg8 = (float)jarg8;
12056   arg9 = (float)jarg9;
12057   {
12058     try {
12059       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
12060     } catch (std::out_of_range& e) {
12061       {
12062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12063       };
12064     } catch (std::exception& e) {
12065       {
12066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12067       };
12068     } catch (...) {
12069       {
12070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12071       };
12072     }
12073   }
12074   jresult = (void *)result;
12075   return jresult;
12076 }
12077
12078
12079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
12080   void * jresult ;
12081   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12082   Dali::Matrix3 *arg2 = 0 ;
12083   Dali::Matrix3 *result = 0 ;
12084
12085   arg1 = (Dali::Matrix3 *)jarg1;
12086   arg2 = (Dali::Matrix3 *)jarg2;
12087   if (!arg2) {
12088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12089     return 0;
12090   }
12091   {
12092     try {
12093       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
12094     } catch (std::out_of_range& e) {
12095       {
12096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12097       };
12098     } catch (std::exception& e) {
12099       {
12100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12101       };
12102     } catch (...) {
12103       {
12104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12105       };
12106     }
12107   }
12108   jresult = (void *)result;
12109   return jresult;
12110 }
12111
12112
12113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
12114   void * jresult ;
12115   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12116   Dali::Matrix *arg2 = 0 ;
12117   Dali::Matrix3 *result = 0 ;
12118
12119   arg1 = (Dali::Matrix3 *)jarg1;
12120   arg2 = (Dali::Matrix *)jarg2;
12121   if (!arg2) {
12122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12123     return 0;
12124   }
12125   {
12126     try {
12127       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12128     } catch (std::out_of_range& e) {
12129       {
12130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12131       };
12132     } catch (std::exception& e) {
12133       {
12134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12135       };
12136     } catch (...) {
12137       {
12138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12139       };
12140     }
12141   }
12142   jresult = (void *)result;
12143   return jresult;
12144 }
12145
12146
12147 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
12148   unsigned int jresult ;
12149   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12150   Dali::Matrix3 *arg2 = 0 ;
12151   bool result;
12152
12153   arg1 = (Dali::Matrix3 *)jarg1;
12154   arg2 = (Dali::Matrix3 *)jarg2;
12155   if (!arg2) {
12156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12157     return 0;
12158   }
12159   {
12160     try {
12161       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
12162     } catch (std::out_of_range& e) {
12163       {
12164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12165       };
12166     } catch (std::exception& e) {
12167       {
12168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12169       };
12170     } catch (...) {
12171       {
12172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12173       };
12174     }
12175   }
12176   jresult = result;
12177   return jresult;
12178 }
12179
12180
12181 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
12182   unsigned int jresult ;
12183   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12184   Dali::Matrix3 *arg2 = 0 ;
12185   bool result;
12186
12187   arg1 = (Dali::Matrix3 *)jarg1;
12188   arg2 = (Dali::Matrix3 *)jarg2;
12189   if (!arg2) {
12190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12191     return 0;
12192   }
12193   {
12194     try {
12195       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
12196     } catch (std::out_of_range& e) {
12197       {
12198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12199       };
12200     } catch (std::exception& e) {
12201       {
12202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12203       };
12204     } catch (...) {
12205       {
12206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12207       };
12208     }
12209   }
12210   jresult = result;
12211   return jresult;
12212 }
12213
12214
12215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
12216   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12217
12218   arg1 = (Dali::Matrix3 *)jarg1;
12219   {
12220     try {
12221       delete arg1;
12222     } catch (std::out_of_range& e) {
12223       {
12224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12225       };
12226     } catch (std::exception& e) {
12227       {
12228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12229       };
12230     } catch (...) {
12231       {
12232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12233       };
12234     }
12235   }
12236 }
12237
12238
12239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
12240   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12241
12242   arg1 = (Dali::Matrix3 *)jarg1;
12243   {
12244     try {
12245       (arg1)->SetIdentity();
12246     } catch (std::out_of_range& e) {
12247       {
12248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12249       };
12250     } catch (std::exception& e) {
12251       {
12252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12253       };
12254     } catch (...) {
12255       {
12256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12257       };
12258     }
12259   }
12260 }
12261
12262
12263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
12264   void * jresult ;
12265   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12266   float *result = 0 ;
12267
12268   arg1 = (Dali::Matrix3 *)jarg1;
12269   {
12270     try {
12271       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
12272     } catch (std::out_of_range& e) {
12273       {
12274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12275       };
12276     } catch (std::exception& e) {
12277       {
12278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12279       };
12280     } catch (...) {
12281       {
12282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12283       };
12284     }
12285   }
12286   jresult = (void *)result;
12287   return jresult;
12288 }
12289
12290
12291 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
12292   unsigned int jresult ;
12293   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12294   bool result;
12295
12296   arg1 = (Dali::Matrix3 *)jarg1;
12297   {
12298     try {
12299       result = (bool)(arg1)->Invert();
12300     } catch (std::out_of_range& e) {
12301       {
12302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12303       };
12304     } catch (std::exception& e) {
12305       {
12306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12307       };
12308     } catch (...) {
12309       {
12310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12311       };
12312     }
12313   }
12314   jresult = result;
12315   return jresult;
12316 }
12317
12318
12319 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
12320   unsigned int jresult ;
12321   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12322   bool result;
12323
12324   arg1 = (Dali::Matrix3 *)jarg1;
12325   {
12326     try {
12327       result = (bool)(arg1)->Transpose();
12328     } catch (std::out_of_range& e) {
12329       {
12330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12331       };
12332     } catch (std::exception& e) {
12333       {
12334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12335       };
12336     } catch (...) {
12337       {
12338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12339       };
12340     }
12341   }
12342   jresult = result;
12343   return jresult;
12344 }
12345
12346
12347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
12348   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12349   float arg2 ;
12350
12351   arg1 = (Dali::Matrix3 *)jarg1;
12352   arg2 = (float)jarg2;
12353   {
12354     try {
12355       (arg1)->Scale(arg2);
12356     } catch (std::out_of_range& e) {
12357       {
12358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12359       };
12360     } catch (std::exception& e) {
12361       {
12362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12363       };
12364     } catch (...) {
12365       {
12366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12367       };
12368     }
12369   }
12370 }
12371
12372
12373 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
12374   float jresult ;
12375   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12376   float result;
12377
12378   arg1 = (Dali::Matrix3 *)jarg1;
12379   {
12380     try {
12381       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
12382     } catch (std::out_of_range& e) {
12383       {
12384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12385       };
12386     } catch (std::exception& e) {
12387       {
12388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12389       };
12390     } catch (...) {
12391       {
12392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12393       };
12394     }
12395   }
12396   jresult = result;
12397   return jresult;
12398 }
12399
12400
12401 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
12402   unsigned int jresult ;
12403   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12404   bool result;
12405
12406   arg1 = (Dali::Matrix3 *)jarg1;
12407   {
12408     try {
12409       result = (bool)(arg1)->ScaledInverseTranspose();
12410     } catch (std::out_of_range& e) {
12411       {
12412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12413       };
12414     } catch (std::exception& e) {
12415       {
12416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12417       };
12418     } catch (...) {
12419       {
12420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12421       };
12422     }
12423   }
12424   jresult = result;
12425   return jresult;
12426 }
12427
12428
12429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
12430   Dali::Matrix3 *arg1 = 0 ;
12431   Dali::Matrix3 *arg2 = 0 ;
12432   Dali::Matrix3 *arg3 = 0 ;
12433
12434   arg1 = (Dali::Matrix3 *)jarg1;
12435   if (!arg1) {
12436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
12437     return ;
12438   }
12439   arg2 = (Dali::Matrix3 *)jarg2;
12440   if (!arg2) {
12441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12442     return ;
12443   }
12444   arg3 = (Dali::Matrix3 *)jarg3;
12445   if (!arg3) {
12446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12447     return ;
12448   }
12449   {
12450     try {
12451       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
12452     } catch (std::out_of_range& e) {
12453       {
12454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12455       };
12456     } catch (std::exception& e) {
12457       {
12458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12459       };
12460     } catch (...) {
12461       {
12462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12463       };
12464     }
12465   }
12466 }
12467
12468
12469 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
12470   float jresult ;
12471   float arg1 ;
12472   float arg2 ;
12473   float result;
12474
12475   arg1 = (float)jarg1;
12476   arg2 = (float)jarg2;
12477   {
12478     try {
12479       result = (float)Dali::Random::Range(arg1,arg2);
12480     } catch (std::out_of_range& e) {
12481       {
12482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12483       };
12484     } catch (std::exception& e) {
12485       {
12486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12487       };
12488     } catch (...) {
12489       {
12490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12491       };
12492     }
12493   }
12494   jresult = result;
12495   return jresult;
12496 }
12497
12498
12499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
12500   void * jresult ;
12501   Dali::Vector4 result;
12502
12503   {
12504     try {
12505       result = Dali::Random::Axis();
12506     } catch (std::out_of_range& e) {
12507       {
12508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12509       };
12510     } catch (std::exception& e) {
12511       {
12512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12513       };
12514     } catch (...) {
12515       {
12516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12517       };
12518     }
12519   }
12520   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
12521   return jresult;
12522 }
12523
12524
12525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
12526   void * jresult ;
12527   Dali::AngleAxis *result = 0 ;
12528
12529   {
12530     try {
12531       result = (Dali::AngleAxis *)new Dali::AngleAxis();
12532     } catch (std::out_of_range& e) {
12533       {
12534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12535       };
12536     } catch (std::exception& e) {
12537       {
12538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12539       };
12540     } catch (...) {
12541       {
12542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12543       };
12544     }
12545   }
12546   jresult = (void *)result;
12547   return jresult;
12548 }
12549
12550
12551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
12552   void * jresult ;
12553   Dali::Radian arg1 ;
12554   Dali::Vector3 *arg2 = 0 ;
12555   Dali::Radian *argp1 ;
12556   Dali::AngleAxis *result = 0 ;
12557
12558   argp1 = (Dali::Radian *)jarg1;
12559   if (!argp1) {
12560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
12561     return 0;
12562   }
12563   arg1 = *argp1;
12564   arg2 = (Dali::Vector3 *)jarg2;
12565   if (!arg2) {
12566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12567     return 0;
12568   }
12569   {
12570     try {
12571       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
12572     } catch (std::out_of_range& e) {
12573       {
12574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12575       };
12576     } catch (std::exception& e) {
12577       {
12578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12579       };
12580     } catch (...) {
12581       {
12582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12583       };
12584     }
12585   }
12586   jresult = (void *)result;
12587   return jresult;
12588 }
12589
12590
12591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
12592   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12593   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
12594
12595   arg1 = (Dali::AngleAxis *)jarg1;
12596   arg2 = (Dali::Radian *)jarg2;
12597   if (arg1) (arg1)->angle = *arg2;
12598 }
12599
12600
12601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
12602   void * jresult ;
12603   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12604   Dali::Radian *result = 0 ;
12605
12606   arg1 = (Dali::AngleAxis *)jarg1;
12607   result = (Dali::Radian *)& ((arg1)->angle);
12608   jresult = (void *)result;
12609   return jresult;
12610 }
12611
12612
12613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
12614   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12615   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
12616
12617   arg1 = (Dali::AngleAxis *)jarg1;
12618   arg2 = (Dali::Vector3 *)jarg2;
12619   if (arg1) (arg1)->axis = *arg2;
12620 }
12621
12622
12623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
12624   void * jresult ;
12625   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12626   Dali::Vector3 *result = 0 ;
12627
12628   arg1 = (Dali::AngleAxis *)jarg1;
12629   result = (Dali::Vector3 *)& ((arg1)->axis);
12630   jresult = (void *)result;
12631   return jresult;
12632 }
12633
12634
12635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
12636   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12637
12638   arg1 = (Dali::AngleAxis *)jarg1;
12639   {
12640     try {
12641       delete arg1;
12642     } catch (std::out_of_range& e) {
12643       {
12644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12645       };
12646     } catch (std::exception& e) {
12647       {
12648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12649       };
12650     } catch (...) {
12651       {
12652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12653       };
12654     }
12655   }
12656 }
12657
12658
12659 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
12660   unsigned int jresult ;
12661   Dali::AngleAxis *arg1 = 0 ;
12662   Dali::AngleAxis *arg2 = 0 ;
12663   bool result;
12664
12665   arg1 = (Dali::AngleAxis *)jarg1;
12666   if (!arg1) {
12667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12668     return 0;
12669   }
12670   arg2 = (Dali::AngleAxis *)jarg2;
12671   if (!arg2) {
12672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12673     return 0;
12674   }
12675   {
12676     try {
12677       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
12678     } catch (std::out_of_range& e) {
12679       {
12680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12681       };
12682     } catch (std::exception& e) {
12683       {
12684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12685       };
12686     } catch (...) {
12687       {
12688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12689       };
12690     }
12691   }
12692   jresult = result;
12693   return jresult;
12694 }
12695
12696
12697 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
12698   unsigned int jresult ;
12699   unsigned int arg1 ;
12700   unsigned int result;
12701
12702   arg1 = (unsigned int)jarg1;
12703   {
12704     try {
12705       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
12706     } catch (std::out_of_range& e) {
12707       {
12708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12709       };
12710     } catch (std::exception& e) {
12711       {
12712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12713       };
12714     } catch (...) {
12715       {
12716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12717       };
12718     }
12719   }
12720   jresult = result;
12721   return jresult;
12722 }
12723
12724
12725 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
12726   unsigned int jresult ;
12727   unsigned int arg1 ;
12728   bool result;
12729
12730   arg1 = (unsigned int)jarg1;
12731   {
12732     try {
12733       result = (bool)Dali::IsPowerOfTwo(arg1);
12734     } catch (std::out_of_range& e) {
12735       {
12736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12737       };
12738     } catch (std::exception& e) {
12739       {
12740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12741       };
12742     } catch (...) {
12743       {
12744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12745       };
12746     }
12747   }
12748   jresult = result;
12749   return jresult;
12750 }
12751
12752
12753 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
12754   float jresult ;
12755   float arg1 ;
12756   float arg2 ;
12757   float result;
12758
12759   arg1 = (float)jarg1;
12760   arg2 = (float)jarg2;
12761   {
12762     try {
12763       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
12764     } catch (std::out_of_range& e) {
12765       {
12766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12767       };
12768     } catch (std::exception& e) {
12769       {
12770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12771       };
12772     } catch (...) {
12773       {
12774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12775       };
12776     }
12777   }
12778   jresult = result;
12779   return jresult;
12780 }
12781
12782
12783 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
12784   unsigned int jresult ;
12785   float arg1 ;
12786   bool result;
12787
12788   arg1 = (float)jarg1;
12789   {
12790     try {
12791       result = (bool)Dali::EqualsZero(arg1);
12792     } catch (std::out_of_range& e) {
12793       {
12794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12795       };
12796     } catch (std::exception& e) {
12797       {
12798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12799       };
12800     } catch (...) {
12801       {
12802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12803       };
12804     }
12805   }
12806   jresult = result;
12807   return jresult;
12808 }
12809
12810
12811 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
12812   unsigned int jresult ;
12813   float arg1 ;
12814   float arg2 ;
12815   bool result;
12816
12817   arg1 = (float)jarg1;
12818   arg2 = (float)jarg2;
12819   {
12820     try {
12821       result = (bool)Dali::Equals(arg1,arg2);
12822     } catch (std::out_of_range& e) {
12823       {
12824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12825       };
12826     } catch (std::exception& e) {
12827       {
12828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12829       };
12830     } catch (...) {
12831       {
12832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12833       };
12834     }
12835   }
12836   jresult = result;
12837   return jresult;
12838 }
12839
12840
12841 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
12842   unsigned int jresult ;
12843   float arg1 ;
12844   float arg2 ;
12845   float arg3 ;
12846   bool result;
12847
12848   arg1 = (float)jarg1;
12849   arg2 = (float)jarg2;
12850   arg3 = (float)jarg3;
12851   {
12852     try {
12853       result = (bool)Dali::Equals(arg1,arg2,arg3);
12854     } catch (std::out_of_range& e) {
12855       {
12856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12857       };
12858     } catch (std::exception& e) {
12859       {
12860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12861       };
12862     } catch (...) {
12863       {
12864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12865       };
12866     }
12867   }
12868   jresult = result;
12869   return jresult;
12870 }
12871
12872
12873 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
12874   float jresult ;
12875   float arg1 ;
12876   int arg2 ;
12877   float result;
12878
12879   arg1 = (float)jarg1;
12880   arg2 = (int)jarg2;
12881   {
12882     try {
12883       result = (float)Dali::Round(arg1,arg2);
12884     } catch (std::out_of_range& e) {
12885       {
12886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12887       };
12888     } catch (std::exception& e) {
12889       {
12890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12891       };
12892     } catch (...) {
12893       {
12894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12895       };
12896     }
12897   }
12898   jresult = result;
12899   return jresult;
12900 }
12901
12902
12903 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
12904   float jresult ;
12905   float arg1 ;
12906   float arg2 ;
12907   float arg3 ;
12908   float result;
12909
12910   arg1 = (float)jarg1;
12911   arg2 = (float)jarg2;
12912   arg3 = (float)jarg3;
12913   {
12914     try {
12915       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
12916     } catch (std::out_of_range& e) {
12917       {
12918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12919       };
12920     } catch (std::exception& e) {
12921       {
12922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12923       };
12924     } catch (...) {
12925       {
12926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12927       };
12928     }
12929   }
12930   jresult = result;
12931   return jresult;
12932 }
12933
12934
12935 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
12936   float jresult ;
12937   float arg1 ;
12938   float arg2 ;
12939   float arg3 ;
12940   float arg4 ;
12941   float result;
12942
12943   arg1 = (float)jarg1;
12944   arg2 = (float)jarg2;
12945   arg3 = (float)jarg3;
12946   arg4 = (float)jarg4;
12947   {
12948     try {
12949       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
12950     } catch (std::out_of_range& e) {
12951       {
12952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12953       };
12954     } catch (std::exception& e) {
12955       {
12956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12957       };
12958     } catch (...) {
12959       {
12960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12961       };
12962     }
12963   }
12964   jresult = result;
12965   return jresult;
12966 }
12967
12968
12969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
12970   int jresult ;
12971   int result;
12972
12973   result = (int)(int)Dali::Property::INVALID_INDEX;
12974   jresult = result;
12975   return jresult;
12976 }
12977
12978
12979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
12980   int jresult ;
12981   int result;
12982
12983   result = (int)(int)Dali::Property::INVALID_KEY;
12984   jresult = result;
12985   return jresult;
12986 }
12987
12988
12989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
12990   int jresult ;
12991   int result;
12992
12993   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
12994   jresult = result;
12995   return jresult;
12996 }
12997
12998
12999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
13000   void * jresult ;
13001   Dali::Handle *arg1 = 0 ;
13002   Dali::Property::Index arg2 ;
13003   Dali::Property *result = 0 ;
13004
13005   arg1 = (Dali::Handle *)jarg1;
13006   if (!arg1) {
13007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13008     return 0;
13009   }
13010   arg2 = (Dali::Property::Index)jarg2;
13011   {
13012     try {
13013       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
13014     } catch (std::out_of_range& e) {
13015       {
13016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13017       };
13018     } catch (std::exception& e) {
13019       {
13020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13021       };
13022     } catch (...) {
13023       {
13024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13025       };
13026     }
13027   }
13028   jresult = (void *)result;
13029   return jresult;
13030 }
13031
13032
13033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
13034   void * jresult ;
13035   Dali::Handle *arg1 = 0 ;
13036   Dali::Property::Index arg2 ;
13037   int arg3 ;
13038   Dali::Property *result = 0 ;
13039
13040   arg1 = (Dali::Handle *)jarg1;
13041   if (!arg1) {
13042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13043     return 0;
13044   }
13045   arg2 = (Dali::Property::Index)jarg2;
13046   arg3 = (int)jarg3;
13047   {
13048     try {
13049       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
13050     } catch (std::out_of_range& e) {
13051       {
13052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13053       };
13054     } catch (std::exception& e) {
13055       {
13056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13057       };
13058     } catch (...) {
13059       {
13060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13061       };
13062     }
13063   }
13064   jresult = (void *)result;
13065   return jresult;
13066 }
13067
13068
13069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
13070   void * jresult ;
13071   Dali::Handle *arg1 = 0 ;
13072   std::string *arg2 = 0 ;
13073   Dali::Property *result = 0 ;
13074
13075   arg1 = (Dali::Handle *)jarg1;
13076   if (!arg1) {
13077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13078     return 0;
13079   }
13080   if (!jarg2) {
13081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13082     return 0;
13083   }
13084   std::string arg2_str(jarg2);
13085   arg2 = &arg2_str;
13086   {
13087     try {
13088       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
13089     } catch (std::out_of_range& e) {
13090       {
13091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13092       };
13093     } catch (std::exception& e) {
13094       {
13095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13096       };
13097     } catch (...) {
13098       {
13099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13100       };
13101     }
13102   }
13103   jresult = (void *)result;
13104
13105   //argout typemap for const std::string&
13106
13107   return jresult;
13108 }
13109
13110
13111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
13112   void * jresult ;
13113   Dali::Handle *arg1 = 0 ;
13114   std::string *arg2 = 0 ;
13115   int arg3 ;
13116   Dali::Property *result = 0 ;
13117
13118   arg1 = (Dali::Handle *)jarg1;
13119   if (!arg1) {
13120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13121     return 0;
13122   }
13123   if (!jarg2) {
13124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13125     return 0;
13126   }
13127   std::string arg2_str(jarg2);
13128   arg2 = &arg2_str;
13129   arg3 = (int)jarg3;
13130   {
13131     try {
13132       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
13133     } catch (std::out_of_range& e) {
13134       {
13135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13136       };
13137     } catch (std::exception& e) {
13138       {
13139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13140       };
13141     } catch (...) {
13142       {
13143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13144       };
13145     }
13146   }
13147   jresult = (void *)result;
13148
13149   //argout typemap for const std::string&
13150
13151   return jresult;
13152 }
13153
13154
13155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
13156   Dali::Property *arg1 = (Dali::Property *) 0 ;
13157
13158   arg1 = (Dali::Property *)jarg1;
13159   {
13160     try {
13161       delete arg1;
13162     } catch (std::out_of_range& e) {
13163       {
13164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13165       };
13166     } catch (std::exception& e) {
13167       {
13168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13169       };
13170     } catch (...) {
13171       {
13172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13173       };
13174     }
13175   }
13176 }
13177
13178
13179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
13180   Dali::Property *arg1 = (Dali::Property *) 0 ;
13181   Dali::Handle *arg2 = 0 ;
13182
13183   arg1 = (Dali::Property *)jarg1;
13184   arg2 = (Dali::Handle *)jarg2;
13185   if (!arg2) {
13186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13187     return ;
13188   }
13189   if (arg1) (arg1)->object = *arg2;
13190 }
13191
13192
13193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
13194   void * jresult ;
13195   Dali::Property *arg1 = (Dali::Property *) 0 ;
13196   Dali::Handle *result = 0 ;
13197
13198   arg1 = (Dali::Property *)jarg1;
13199   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
13200   jresult = (void *)result;
13201   return jresult;
13202 }
13203
13204
13205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
13206   Dali::Property *arg1 = (Dali::Property *) 0 ;
13207   Dali::Property::Index arg2 ;
13208
13209   arg1 = (Dali::Property *)jarg1;
13210   arg2 = (Dali::Property::Index)jarg2;
13211   if (arg1) (arg1)->propertyIndex = arg2;
13212 }
13213
13214
13215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
13216   int jresult ;
13217   Dali::Property *arg1 = (Dali::Property *) 0 ;
13218   Dali::Property::Index result;
13219
13220   arg1 = (Dali::Property *)jarg1;
13221   result = (Dali::Property::Index) ((arg1)->propertyIndex);
13222   jresult = result;
13223   return jresult;
13224 }
13225
13226
13227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
13228   Dali::Property *arg1 = (Dali::Property *) 0 ;
13229   int arg2 ;
13230
13231   arg1 = (Dali::Property *)jarg1;
13232   arg2 = (int)jarg2;
13233   if (arg1) (arg1)->componentIndex = arg2;
13234 }
13235
13236
13237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
13238   int jresult ;
13239   Dali::Property *arg1 = (Dali::Property *) 0 ;
13240   int result;
13241
13242   arg1 = (Dali::Property *)jarg1;
13243   result = (int) ((arg1)->componentIndex);
13244   jresult = result;
13245   return jresult;
13246 }
13247
13248
13249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
13250   void * jresult ;
13251   Dali::Property::Array *result = 0 ;
13252
13253   {
13254     try {
13255       result = (Dali::Property::Array *)new Dali::Property::Array();
13256     } catch (std::out_of_range& e) {
13257       {
13258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13259       };
13260     } catch (std::exception& e) {
13261       {
13262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13263       };
13264     } catch (...) {
13265       {
13266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13267       };
13268     }
13269   }
13270   jresult = (void *)result;
13271   return jresult;
13272 }
13273
13274
13275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
13276   void * jresult ;
13277   Dali::Property::Array *arg1 = 0 ;
13278   Dali::Property::Array *result = 0 ;
13279
13280   arg1 = (Dali::Property::Array *)jarg1;
13281   if (!arg1) {
13282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13283     return 0;
13284   }
13285   {
13286     try {
13287       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
13288     } catch (std::out_of_range& e) {
13289       {
13290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13291       };
13292     } catch (std::exception& e) {
13293       {
13294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13295       };
13296     } catch (...) {
13297       {
13298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13299       };
13300     }
13301   }
13302   jresult = (void *)result;
13303   return jresult;
13304 }
13305
13306
13307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
13308   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13309
13310   arg1 = (Dali::Property::Array *)jarg1;
13311   {
13312     try {
13313       delete arg1;
13314     } catch (std::out_of_range& e) {
13315       {
13316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13317       };
13318     } catch (std::exception& e) {
13319       {
13320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13321       };
13322     } catch (...) {
13323       {
13324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13325       };
13326     }
13327   }
13328 }
13329
13330
13331 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
13332   unsigned long jresult ;
13333   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13334   Dali::Property::Array::SizeType result;
13335
13336   arg1 = (Dali::Property::Array *)jarg1;
13337   {
13338     try {
13339       result = ((Dali::Property::Array const *)arg1)->Size();
13340     } catch (std::out_of_range& e) {
13341       {
13342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13343       };
13344     } catch (std::exception& e) {
13345       {
13346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13347       };
13348     } catch (...) {
13349       {
13350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13351       };
13352     }
13353   }
13354   jresult = (unsigned long)result;
13355   return jresult;
13356 }
13357
13358
13359 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
13360   unsigned long jresult ;
13361   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13362   Dali::Property::Array::SizeType result;
13363
13364   arg1 = (Dali::Property::Array *)jarg1;
13365   {
13366     try {
13367       result = ((Dali::Property::Array const *)arg1)->Count();
13368     } catch (std::out_of_range& e) {
13369       {
13370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13371       };
13372     } catch (std::exception& e) {
13373       {
13374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13375       };
13376     } catch (...) {
13377       {
13378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13379       };
13380     }
13381   }
13382   jresult = (unsigned long)result;
13383   return jresult;
13384 }
13385
13386
13387 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
13388   unsigned int jresult ;
13389   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13390   bool result;
13391
13392   arg1 = (Dali::Property::Array *)jarg1;
13393   {
13394     try {
13395       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
13396     } catch (std::out_of_range& e) {
13397       {
13398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13399       };
13400     } catch (std::exception& e) {
13401       {
13402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13403       };
13404     } catch (...) {
13405       {
13406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13407       };
13408     }
13409   }
13410   jresult = result;
13411   return jresult;
13412 }
13413
13414
13415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
13416   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13417
13418   arg1 = (Dali::Property::Array *)jarg1;
13419   {
13420     try {
13421       (arg1)->Clear();
13422     } catch (std::out_of_range& e) {
13423       {
13424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13425       };
13426     } catch (std::exception& e) {
13427       {
13428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13429       };
13430     } catch (...) {
13431       {
13432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13433       };
13434     }
13435   }
13436 }
13437
13438
13439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
13440   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13441   Dali::Property::Array::SizeType arg2 ;
13442
13443   arg1 = (Dali::Property::Array *)jarg1;
13444   arg2 = (Dali::Property::Array::SizeType)jarg2;
13445   {
13446     try {
13447       (arg1)->Reserve(arg2);
13448     } catch (std::out_of_range& e) {
13449       {
13450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13451       };
13452     } catch (std::exception& e) {
13453       {
13454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13455       };
13456     } catch (...) {
13457       {
13458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13459       };
13460     }
13461   }
13462 }
13463
13464
13465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
13466   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13467   Dali::Property::Array::SizeType arg2 ;
13468
13469   arg1 = (Dali::Property::Array *)jarg1;
13470   arg2 = (Dali::Property::Array::SizeType)jarg2;
13471   {
13472     try {
13473       (arg1)->Resize(arg2);
13474     } catch (std::out_of_range& e) {
13475       {
13476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13477       };
13478     } catch (std::exception& e) {
13479       {
13480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13481       };
13482     } catch (...) {
13483       {
13484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13485       };
13486     }
13487   }
13488 }
13489
13490
13491 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
13492   unsigned long jresult ;
13493   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13494   Dali::Property::Array::SizeType result;
13495
13496   arg1 = (Dali::Property::Array *)jarg1;
13497   {
13498     try {
13499       result = (arg1)->Capacity();
13500     } catch (std::out_of_range& e) {
13501       {
13502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13503       };
13504     } catch (std::exception& e) {
13505       {
13506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13507       };
13508     } catch (...) {
13509       {
13510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13511       };
13512     }
13513   }
13514   jresult = (unsigned long)result;
13515   return jresult;
13516 }
13517
13518
13519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
13520   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13521   Dali::Property::Value *arg2 = 0 ;
13522
13523   arg1 = (Dali::Property::Array *)jarg1;
13524   arg2 = (Dali::Property::Value *)jarg2;
13525   if (!arg2) {
13526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13527     return ;
13528   }
13529   {
13530     try {
13531       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
13532     } catch (std::out_of_range& e) {
13533       {
13534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13535       };
13536     } catch (std::exception& e) {
13537       {
13538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13539       };
13540     } catch (...) {
13541       {
13542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13543       };
13544     }
13545   }
13546 }
13547
13548
13549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
13550   void * jresult ;
13551   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13552   Dali::Property::Value *arg2 = 0 ;
13553   Dali::Property::Array *result = 0 ;
13554
13555   arg1 = (Dali::Property::Array *)jarg1;
13556   arg2 = (Dali::Property::Value *)jarg2;
13557   if (!arg2) {
13558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13559     return 0;
13560   }
13561   {
13562     try {
13563       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
13564     } catch (std::out_of_range& e) {
13565       {
13566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13567       };
13568     } catch (std::exception& e) {
13569       {
13570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13571       };
13572     } catch (...) {
13573       {
13574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13575       };
13576     }
13577   }
13578   jresult = (void *)result;
13579   return jresult;
13580 }
13581
13582
13583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
13584   void * jresult ;
13585   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13586   Dali::Property::Array::SizeType arg2 ;
13587   Dali::Property::Value *result = 0 ;
13588
13589   arg1 = (Dali::Property::Array *)jarg1;
13590   arg2 = (Dali::Property::Array::SizeType)jarg2;
13591   {
13592     try {
13593       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
13594     } catch (std::out_of_range& e) {
13595       {
13596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13597       };
13598     } catch (std::exception& e) {
13599       {
13600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13601       };
13602     } catch (...) {
13603       {
13604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13605       };
13606     }
13607   }
13608   jresult = (void *)result;
13609   return jresult;
13610 }
13611
13612
13613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
13614   void * jresult ;
13615   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13616   Dali::Property::Array::SizeType arg2 ;
13617   Dali::Property::Value *result = 0 ;
13618
13619   arg1 = (Dali::Property::Array *)jarg1;
13620   arg2 = (Dali::Property::Array::SizeType)jarg2;
13621   {
13622     try {
13623       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
13624     } catch (std::out_of_range& e) {
13625       {
13626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13627       };
13628     } catch (std::exception& e) {
13629       {
13630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13631       };
13632     } catch (...) {
13633       {
13634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13635       };
13636     }
13637   }
13638   jresult = (void *)result;
13639   return jresult;
13640 }
13641
13642
13643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
13644   void * jresult ;
13645   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13646   Dali::Property::Array *arg2 = 0 ;
13647   Dali::Property::Array *result = 0 ;
13648
13649   arg1 = (Dali::Property::Array *)jarg1;
13650   arg2 = (Dali::Property::Array *)jarg2;
13651   if (!arg2) {
13652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13653     return 0;
13654   }
13655   {
13656     try {
13657       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
13658     } catch (std::out_of_range& e) {
13659       {
13660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13661       };
13662     } catch (std::exception& e) {
13663       {
13664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13665       };
13666     } catch (...) {
13667       {
13668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13669       };
13670     }
13671   }
13672   jresult = (void *)result;
13673   return jresult;
13674 }
13675
13676
13677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
13678   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13679   enum Dali::Property::Key::Type arg2 ;
13680
13681   arg1 = (Dali::Property::Key *)jarg1;
13682   arg2 = (enum Dali::Property::Key::Type)jarg2;
13683   if (arg1) (arg1)->type = arg2;
13684 }
13685
13686
13687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
13688   int jresult ;
13689   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13690   enum Dali::Property::Key::Type result;
13691
13692   arg1 = (Dali::Property::Key *)jarg1;
13693   result = (enum Dali::Property::Key::Type) ((arg1)->type);
13694   jresult = (int)result;
13695   return jresult;
13696 }
13697
13698
13699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
13700   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13701   Dali::Property::Index arg2 ;
13702
13703   arg1 = (Dali::Property::Key *)jarg1;
13704   arg2 = (Dali::Property::Index)jarg2;
13705   if (arg1) (arg1)->indexKey = arg2;
13706 }
13707
13708
13709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
13710   int jresult ;
13711   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13712   Dali::Property::Index result;
13713
13714   arg1 = (Dali::Property::Key *)jarg1;
13715   result = (Dali::Property::Index) ((arg1)->indexKey);
13716   jresult = result;
13717   return jresult;
13718 }
13719
13720
13721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
13722   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13723   std::string *arg2 = 0 ;
13724
13725   arg1 = (Dali::Property::Key *)jarg1;
13726   if (!jarg2) {
13727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13728     return ;
13729   }
13730   std::string arg2_str(jarg2);
13731   arg2 = &arg2_str;
13732   if (arg1) (arg1)->stringKey = *arg2;
13733
13734   //argout typemap for const std::string&
13735
13736 }
13737
13738
13739 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
13740   char * jresult ;
13741   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13742   std::string *result = 0 ;
13743
13744   arg1 = (Dali::Property::Key *)jarg1;
13745   result = (std::string *) & ((arg1)->stringKey);
13746   jresult = SWIG_csharp_string_callback(result->c_str());
13747   return jresult;
13748 }
13749
13750
13751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
13752   void * jresult ;
13753   std::string *arg1 = 0 ;
13754   Dali::Property::Key *result = 0 ;
13755
13756   if (!jarg1) {
13757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13758     return 0;
13759   }
13760   std::string arg1_str(jarg1);
13761   arg1 = &arg1_str;
13762   {
13763     try {
13764       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
13765     } catch (std::out_of_range& e) {
13766       {
13767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13768       };
13769     } catch (std::exception& e) {
13770       {
13771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13772       };
13773     } catch (...) {
13774       {
13775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13776       };
13777     }
13778   }
13779   jresult = (void *)result;
13780
13781   //argout typemap for const std::string&
13782
13783   return jresult;
13784 }
13785
13786
13787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
13788   void * jresult ;
13789   Dali::Property::Index arg1 ;
13790   Dali::Property::Key *result = 0 ;
13791
13792   arg1 = (Dali::Property::Index)jarg1;
13793   {
13794     try {
13795       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
13796     } catch (std::out_of_range& e) {
13797       {
13798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13799       };
13800     } catch (std::exception& e) {
13801       {
13802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13803       };
13804     } catch (...) {
13805       {
13806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13807       };
13808     }
13809   }
13810   jresult = (void *)result;
13811   return jresult;
13812 }
13813
13814
13815 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
13816   unsigned int jresult ;
13817   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13818   std::string *arg2 = 0 ;
13819   bool result;
13820
13821   arg1 = (Dali::Property::Key *)jarg1;
13822   if (!jarg2) {
13823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13824     return 0;
13825   }
13826   std::string arg2_str(jarg2);
13827   arg2 = &arg2_str;
13828   {
13829     try {
13830       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
13831     } catch (std::out_of_range& e) {
13832       {
13833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13834       };
13835     } catch (std::exception& e) {
13836       {
13837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13838       };
13839     } catch (...) {
13840       {
13841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13842       };
13843     }
13844   }
13845   jresult = result;
13846
13847   //argout typemap for const std::string&
13848
13849   return jresult;
13850 }
13851
13852
13853 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
13854   unsigned int jresult ;
13855   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13856   Dali::Property::Index arg2 ;
13857   bool result;
13858
13859   arg1 = (Dali::Property::Key *)jarg1;
13860   arg2 = (Dali::Property::Index)jarg2;
13861   {
13862     try {
13863       result = (bool)(arg1)->operator ==(arg2);
13864     } catch (std::out_of_range& e) {
13865       {
13866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13867       };
13868     } catch (std::exception& e) {
13869       {
13870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13871       };
13872     } catch (...) {
13873       {
13874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13875       };
13876     }
13877   }
13878   jresult = result;
13879   return jresult;
13880 }
13881
13882
13883 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
13884   unsigned int jresult ;
13885   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13886   Dali::Property::Key *arg2 = 0 ;
13887   bool result;
13888
13889   arg1 = (Dali::Property::Key *)jarg1;
13890   arg2 = (Dali::Property::Key *)jarg2;
13891   if (!arg2) {
13892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13893     return 0;
13894   }
13895   {
13896     try {
13897       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
13898     } catch (std::out_of_range& e) {
13899       {
13900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13901       };
13902     } catch (std::exception& e) {
13903       {
13904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13905       };
13906     } catch (...) {
13907       {
13908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13909       };
13910     }
13911   }
13912   jresult = result;
13913   return jresult;
13914 }
13915
13916
13917 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
13918   unsigned int jresult ;
13919   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13920   std::string *arg2 = 0 ;
13921   bool result;
13922
13923   arg1 = (Dali::Property::Key *)jarg1;
13924   if (!jarg2) {
13925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13926     return 0;
13927   }
13928   std::string arg2_str(jarg2);
13929   arg2 = &arg2_str;
13930   {
13931     try {
13932       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
13933     } catch (std::out_of_range& e) {
13934       {
13935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13936       };
13937     } catch (std::exception& e) {
13938       {
13939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13940       };
13941     } catch (...) {
13942       {
13943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13944       };
13945     }
13946   }
13947   jresult = result;
13948
13949   //argout typemap for const std::string&
13950
13951   return jresult;
13952 }
13953
13954
13955 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
13956   unsigned int jresult ;
13957   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13958   Dali::Property::Index arg2 ;
13959   bool result;
13960
13961   arg1 = (Dali::Property::Key *)jarg1;
13962   arg2 = (Dali::Property::Index)jarg2;
13963   {
13964     try {
13965       result = (bool)(arg1)->operator !=(arg2);
13966     } catch (std::out_of_range& e) {
13967       {
13968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13969       };
13970     } catch (std::exception& e) {
13971       {
13972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13973       };
13974     } catch (...) {
13975       {
13976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13977       };
13978     }
13979   }
13980   jresult = result;
13981   return jresult;
13982 }
13983
13984
13985 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
13986   unsigned int jresult ;
13987   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13988   Dali::Property::Key *arg2 = 0 ;
13989   bool result;
13990
13991   arg1 = (Dali::Property::Key *)jarg1;
13992   arg2 = (Dali::Property::Key *)jarg2;
13993   if (!arg2) {
13994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13995     return 0;
13996   }
13997   {
13998     try {
13999       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
14000     } catch (std::out_of_range& e) {
14001       {
14002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14003       };
14004     } catch (std::exception& e) {
14005       {
14006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14007       };
14008     } catch (...) {
14009       {
14010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14011       };
14012     }
14013   }
14014   jresult = result;
14015   return jresult;
14016 }
14017
14018
14019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
14020   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
14021
14022   arg1 = (Dali::Property::Key *)jarg1;
14023   {
14024     try {
14025       delete arg1;
14026     } catch (std::out_of_range& e) {
14027       {
14028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14029       };
14030     } catch (std::exception& e) {
14031       {
14032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14033       };
14034     } catch (...) {
14035       {
14036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14037       };
14038     }
14039   }
14040 }
14041
14042
14043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
14044   void * jresult ;
14045   Dali::Property::Map *result = 0 ;
14046
14047   {
14048     try {
14049       result = (Dali::Property::Map *)new Dali::Property::Map();
14050     } catch (std::out_of_range& e) {
14051       {
14052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14053       };
14054     } catch (std::exception& e) {
14055       {
14056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14057       };
14058     } catch (...) {
14059       {
14060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14061       };
14062     }
14063   }
14064   jresult = (void *)result;
14065   return jresult;
14066 }
14067
14068
14069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
14070   void * jresult ;
14071   Dali::Property::Map *arg1 = 0 ;
14072   Dali::Property::Map *result = 0 ;
14073
14074   arg1 = (Dali::Property::Map *)jarg1;
14075   if (!arg1) {
14076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14077     return 0;
14078   }
14079   {
14080     try {
14081       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
14082     } catch (std::out_of_range& e) {
14083       {
14084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14085       };
14086     } catch (std::exception& e) {
14087       {
14088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14089       };
14090     } catch (...) {
14091       {
14092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14093       };
14094     }
14095   }
14096   jresult = (void *)result;
14097   return jresult;
14098 }
14099
14100
14101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
14102   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14103
14104   arg1 = (Dali::Property::Map *)jarg1;
14105   {
14106     try {
14107       delete arg1;
14108     } catch (std::out_of_range& e) {
14109       {
14110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14111       };
14112     } catch (std::exception& e) {
14113       {
14114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14115       };
14116     } catch (...) {
14117       {
14118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14119       };
14120     }
14121   }
14122 }
14123
14124
14125 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
14126   unsigned long jresult ;
14127   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14128   Dali::Property::Map::SizeType result;
14129
14130   arg1 = (Dali::Property::Map *)jarg1;
14131   {
14132     try {
14133       result = ((Dali::Property::Map const *)arg1)->Count();
14134     } catch (std::out_of_range& e) {
14135       {
14136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14137       };
14138     } catch (std::exception& e) {
14139       {
14140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14141       };
14142     } catch (...) {
14143       {
14144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14145       };
14146     }
14147   }
14148   jresult = (unsigned long)result;
14149   return jresult;
14150 }
14151
14152
14153 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
14154   unsigned int jresult ;
14155   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14156   bool result;
14157
14158   arg1 = (Dali::Property::Map *)jarg1;
14159   {
14160     try {
14161       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
14162     } catch (std::out_of_range& e) {
14163       {
14164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14165       };
14166     } catch (std::exception& e) {
14167       {
14168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14169       };
14170     } catch (...) {
14171       {
14172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14173       };
14174     }
14175   }
14176   jresult = result;
14177   return jresult;
14178 }
14179
14180
14181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14182   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14183   char *arg2 = (char *) 0 ;
14184   Dali::Property::Value *arg3 = 0 ;
14185
14186   arg1 = (Dali::Property::Map *)jarg1;
14187   arg2 = (char *)jarg2;
14188   arg3 = (Dali::Property::Value *)jarg3;
14189   if (!arg3) {
14190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14191     return ;
14192   }
14193   {
14194     try {
14195       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
14196     } catch (std::out_of_range& e) {
14197       {
14198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14199       };
14200     } catch (std::exception& e) {
14201       {
14202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14203       };
14204     } catch (...) {
14205       {
14206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14207       };
14208     }
14209   }
14210 }
14211
14212
14213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14214   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14215   Dali::Property::Index arg2 ;
14216   Dali::Property::Value *arg3 = 0 ;
14217
14218   arg1 = (Dali::Property::Map *)jarg1;
14219   arg2 = (Dali::Property::Index)jarg2;
14220   arg3 = (Dali::Property::Value *)jarg3;
14221   if (!arg3) {
14222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14223     return ;
14224   }
14225   {
14226     try {
14227       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
14228     } catch (std::out_of_range& e) {
14229       {
14230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14231       };
14232     } catch (std::exception& e) {
14233       {
14234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14235       };
14236     } catch (...) {
14237       {
14238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14239       };
14240     }
14241   }
14242 }
14243
14244
14245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14246   void * jresult ;
14247   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14248   char *arg2 = (char *) 0 ;
14249   Dali::Property::Value *arg3 = 0 ;
14250   Dali::Property::Map *result = 0 ;
14251
14252   arg1 = (Dali::Property::Map *)jarg1;
14253   arg2 = (char *)jarg2;
14254   arg3 = (Dali::Property::Value *)jarg3;
14255   if (!arg3) {
14256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14257     return 0;
14258   }
14259   {
14260     try {
14261       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
14262     } catch (std::out_of_range& e) {
14263       {
14264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14265       };
14266     } catch (std::exception& e) {
14267       {
14268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14269       };
14270     } catch (...) {
14271       {
14272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14273       };
14274     }
14275   }
14276   jresult = (void *)result;
14277   return jresult;
14278 }
14279
14280
14281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14282   void * jresult ;
14283   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14284   Dali::Property::Index arg2 ;
14285   Dali::Property::Value *arg3 = 0 ;
14286   Dali::Property::Map *result = 0 ;
14287
14288   arg1 = (Dali::Property::Map *)jarg1;
14289   arg2 = (Dali::Property::Index)jarg2;
14290   arg3 = (Dali::Property::Value *)jarg3;
14291   if (!arg3) {
14292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14293     return 0;
14294   }
14295   {
14296     try {
14297       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
14298     } catch (std::out_of_range& e) {
14299       {
14300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14301       };
14302     } catch (std::exception& e) {
14303       {
14304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14305       };
14306     } catch (...) {
14307       {
14308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14309       };
14310     }
14311   }
14312   jresult = (void *)result;
14313   return jresult;
14314 }
14315
14316
14317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
14318   void * jresult ;
14319   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14320   Dali::Property::Map::SizeType arg2 ;
14321   Dali::Property::Value *result = 0 ;
14322
14323   arg1 = (Dali::Property::Map *)jarg1;
14324   arg2 = (Dali::Property::Map::SizeType)jarg2;
14325   {
14326     try {
14327       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
14328     } catch (std::out_of_range& e) {
14329       {
14330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14331       };
14332     } catch (std::exception& e) {
14333       {
14334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14335       };
14336     } catch (...) {
14337       {
14338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14339       };
14340     }
14341   }
14342   jresult = (void *)result;
14343   return jresult;
14344 }
14345
14346
14347 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
14348   char * jresult ;
14349   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14350   Dali::Property::Map::SizeType arg2 ;
14351   std::string *result = 0 ;
14352
14353   arg1 = (Dali::Property::Map *)jarg1;
14354   arg2 = (Dali::Property::Map::SizeType)jarg2;
14355   {
14356     try {
14357       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
14358     } catch (std::out_of_range& e) {
14359       {
14360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14361       };
14362     } catch (std::exception& e) {
14363       {
14364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14365       };
14366     } catch (...) {
14367       {
14368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14369       };
14370     }
14371   }
14372   jresult = SWIG_csharp_string_callback(result->c_str());
14373   return jresult;
14374 }
14375
14376
14377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
14378   void * jresult ;
14379   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14380   Dali::Property::Map::SizeType arg2 ;
14381   SwigValueWrapper< Dali::Property::Key > result;
14382
14383   arg1 = (Dali::Property::Map *)jarg1;
14384   arg2 = (Dali::Property::Map::SizeType)jarg2;
14385   {
14386     try {
14387       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
14388     } catch (std::out_of_range& e) {
14389       {
14390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14391       };
14392     } catch (std::exception& e) {
14393       {
14394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14395       };
14396     } catch (...) {
14397       {
14398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14399       };
14400     }
14401   }
14402   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
14403   return jresult;
14404 }
14405
14406
14407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
14408   void * jresult ;
14409   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14410   Dali::Property::Map::SizeType arg2 ;
14411   StringValuePair *result = 0 ;
14412
14413   arg1 = (Dali::Property::Map *)jarg1;
14414   arg2 = (Dali::Property::Map::SizeType)jarg2;
14415   {
14416     try {
14417       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
14418     } catch (std::out_of_range& e) {
14419       {
14420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14421       };
14422     } catch (std::exception& e) {
14423       {
14424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14425       };
14426     } catch (...) {
14427       {
14428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14429       };
14430     }
14431   }
14432   jresult = (void *)result;
14433   return jresult;
14434 }
14435
14436
14437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
14438   void * jresult ;
14439   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14440   char *arg2 = (char *) 0 ;
14441   Dali::Property::Value *result = 0 ;
14442
14443   arg1 = (Dali::Property::Map *)jarg1;
14444   arg2 = (char *)jarg2;
14445   {
14446     try {
14447       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
14448     } catch (std::out_of_range& e) {
14449       {
14450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14451       };
14452     } catch (std::exception& e) {
14453       {
14454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14455       };
14456     } catch (...) {
14457       {
14458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14459       };
14460     }
14461   }
14462   jresult = (void *)result;
14463   return jresult;
14464 }
14465
14466
14467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
14468   void * jresult ;
14469   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14470   Dali::Property::Index arg2 ;
14471   Dali::Property::Value *result = 0 ;
14472
14473   arg1 = (Dali::Property::Map *)jarg1;
14474   arg2 = (Dali::Property::Index)jarg2;
14475   {
14476     try {
14477       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
14478     } catch (std::out_of_range& e) {
14479       {
14480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14481       };
14482     } catch (std::exception& e) {
14483       {
14484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14485       };
14486     } catch (...) {
14487       {
14488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14489       };
14490     }
14491   }
14492   jresult = (void *)result;
14493   return jresult;
14494 }
14495
14496
14497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
14498   void * jresult ;
14499   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14500   Dali::Property::Index arg2 ;
14501   std::string *arg3 = 0 ;
14502   Dali::Property::Value *result = 0 ;
14503
14504   arg1 = (Dali::Property::Map *)jarg1;
14505   arg2 = (Dali::Property::Index)jarg2;
14506   if (!jarg3) {
14507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14508     return 0;
14509   }
14510   std::string arg3_str(jarg3);
14511   arg3 = &arg3_str;
14512   {
14513     try {
14514       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
14515     } catch (std::out_of_range& e) {
14516       {
14517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14518       };
14519     } catch (std::exception& e) {
14520       {
14521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14522       };
14523     } catch (...) {
14524       {
14525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14526       };
14527     }
14528   }
14529   jresult = (void *)result;
14530
14531   //argout typemap for const std::string&
14532
14533   return jresult;
14534 }
14535
14536
14537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
14538   void * jresult ;
14539   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14540   std::string *arg2 = 0 ;
14541   Dali::Property::Type arg3 ;
14542   Dali::Property::Value *result = 0 ;
14543
14544   arg1 = (Dali::Property::Map *)jarg1;
14545   if (!jarg2) {
14546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14547     return 0;
14548   }
14549   std::string arg2_str(jarg2);
14550   arg2 = &arg2_str;
14551   arg3 = (Dali::Property::Type)jarg3;
14552   {
14553     try {
14554       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
14555     } catch (std::out_of_range& e) {
14556       {
14557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14558       };
14559     } catch (std::exception& e) {
14560       {
14561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14562       };
14563     } catch (...) {
14564       {
14565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14566       };
14567     }
14568   }
14569   jresult = (void *)result;
14570
14571   //argout typemap for const std::string&
14572
14573   return jresult;
14574 }
14575
14576
14577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
14578   void * jresult ;
14579   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14580   Dali::Property::Index arg2 ;
14581   Dali::Property::Type arg3 ;
14582   Dali::Property::Value *result = 0 ;
14583
14584   arg1 = (Dali::Property::Map *)jarg1;
14585   arg2 = (Dali::Property::Index)jarg2;
14586   arg3 = (Dali::Property::Type)jarg3;
14587   {
14588     try {
14589       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
14590     } catch (std::out_of_range& e) {
14591       {
14592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14593       };
14594     } catch (std::exception& e) {
14595       {
14596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14597       };
14598     } catch (...) {
14599       {
14600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14601       };
14602     }
14603   }
14604   jresult = (void *)result;
14605   return jresult;
14606 }
14607
14608
14609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
14610   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14611
14612   arg1 = (Dali::Property::Map *)jarg1;
14613   {
14614     try {
14615       (arg1)->Clear();
14616     } catch (std::out_of_range& e) {
14617       {
14618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14619       };
14620     } catch (std::exception& e) {
14621       {
14622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14623       };
14624     } catch (...) {
14625       {
14626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14627       };
14628     }
14629   }
14630 }
14631
14632
14633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
14634   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14635   Dali::Property::Map *arg2 = 0 ;
14636
14637   arg1 = (Dali::Property::Map *)jarg1;
14638   arg2 = (Dali::Property::Map *)jarg2;
14639   if (!arg2) {
14640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14641     return ;
14642   }
14643   {
14644     try {
14645       (arg1)->Merge((Dali::Property::Map const &)*arg2);
14646     } catch (std::out_of_range& e) {
14647       {
14648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14649       };
14650     } catch (std::exception& e) {
14651       {
14652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14653       };
14654     } catch (...) {
14655       {
14656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14657       };
14658     }
14659   }
14660 }
14661
14662
14663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
14664   void * jresult ;
14665   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14666   std::string *arg2 = 0 ;
14667   Dali::Property::Value *result = 0 ;
14668
14669   arg1 = (Dali::Property::Map *)jarg1;
14670   if (!jarg2) {
14671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14672     return 0;
14673   }
14674   std::string arg2_str(jarg2);
14675   arg2 = &arg2_str;
14676   {
14677     try {
14678       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
14679     } catch (std::out_of_range& e) {
14680       {
14681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14682       };
14683     } catch (std::exception& e) {
14684       {
14685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14686       };
14687     } catch (...) {
14688       {
14689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14690       };
14691     }
14692   }
14693   jresult = (void *)result;
14694
14695   //argout typemap for const std::string&
14696
14697   return jresult;
14698 }
14699
14700
14701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
14702   void * jresult ;
14703   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14704   Dali::Property::Index arg2 ;
14705   Dali::Property::Value *result = 0 ;
14706
14707   arg1 = (Dali::Property::Map *)jarg1;
14708   arg2 = (Dali::Property::Index)jarg2;
14709   {
14710     try {
14711       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
14712     } catch (std::out_of_range& e) {
14713       {
14714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14715       };
14716     } catch (std::exception& e) {
14717       {
14718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14719       };
14720     } catch (...) {
14721       {
14722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14723       };
14724     }
14725   }
14726   jresult = (void *)result;
14727   return jresult;
14728 }
14729
14730
14731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
14732   void * jresult ;
14733   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14734   Dali::Property::Map *arg2 = 0 ;
14735   Dali::Property::Map *result = 0 ;
14736
14737   arg1 = (Dali::Property::Map *)jarg1;
14738   arg2 = (Dali::Property::Map *)jarg2;
14739   if (!arg2) {
14740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14741     return 0;
14742   }
14743   {
14744     try {
14745       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
14746     } catch (std::out_of_range& e) {
14747       {
14748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14749       };
14750     } catch (std::exception& e) {
14751       {
14752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14753       };
14754     } catch (...) {
14755       {
14756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14757       };
14758     }
14759   }
14760   jresult = (void *)result;
14761   return jresult;
14762 }
14763
14764
14765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
14766   void * jresult ;
14767   Dali::Property::Value *result = 0 ;
14768
14769   {
14770     try {
14771       result = (Dali::Property::Value *)new Dali::Property::Value();
14772     } catch (std::out_of_range& e) {
14773       {
14774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14775       };
14776     } catch (std::exception& e) {
14777       {
14778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14779       };
14780     } catch (...) {
14781       {
14782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14783       };
14784     }
14785   }
14786   jresult = (void *)result;
14787   return jresult;
14788 }
14789
14790
14791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
14792   void * jresult ;
14793   bool arg1 ;
14794   Dali::Property::Value *result = 0 ;
14795
14796   arg1 = jarg1 ? true : false;
14797   {
14798     try {
14799       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14800     } catch (std::out_of_range& e) {
14801       {
14802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14803       };
14804     } catch (std::exception& e) {
14805       {
14806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14807       };
14808     } catch (...) {
14809       {
14810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14811       };
14812     }
14813   }
14814   jresult = (void *)result;
14815   return jresult;
14816 }
14817
14818
14819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
14820   void * jresult ;
14821   int arg1 ;
14822   Dali::Property::Value *result = 0 ;
14823
14824   arg1 = (int)jarg1;
14825   {
14826     try {
14827       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14828     } catch (std::out_of_range& e) {
14829       {
14830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14831       };
14832     } catch (std::exception& e) {
14833       {
14834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14835       };
14836     } catch (...) {
14837       {
14838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14839       };
14840     }
14841   }
14842   jresult = (void *)result;
14843   return jresult;
14844 }
14845
14846
14847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
14848   void * jresult ;
14849   float arg1 ;
14850   Dali::Property::Value *result = 0 ;
14851
14852   arg1 = (float)jarg1;
14853   {
14854     try {
14855       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14856     } catch (std::out_of_range& e) {
14857       {
14858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14859       };
14860     } catch (std::exception& e) {
14861       {
14862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14863       };
14864     } catch (...) {
14865       {
14866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14867       };
14868     }
14869   }
14870   jresult = (void *)result;
14871   return jresult;
14872 }
14873
14874
14875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
14876   void * jresult ;
14877   Dali::Vector2 *arg1 = 0 ;
14878   Dali::Property::Value *result = 0 ;
14879
14880   arg1 = (Dali::Vector2 *)jarg1;
14881   if (!arg1) {
14882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
14883     return 0;
14884   }
14885   {
14886     try {
14887       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
14888     } catch (std::out_of_range& e) {
14889       {
14890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14891       };
14892     } catch (std::exception& e) {
14893       {
14894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14895       };
14896     } catch (...) {
14897       {
14898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14899       };
14900     }
14901   }
14902   jresult = (void *)result;
14903   return jresult;
14904 }
14905
14906
14907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
14908   void * jresult ;
14909   Dali::Vector3 *arg1 = 0 ;
14910   Dali::Property::Value *result = 0 ;
14911
14912   arg1 = (Dali::Vector3 *)jarg1;
14913   if (!arg1) {
14914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14915     return 0;
14916   }
14917   {
14918     try {
14919       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
14920     } catch (std::out_of_range& e) {
14921       {
14922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14923       };
14924     } catch (std::exception& e) {
14925       {
14926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14927       };
14928     } catch (...) {
14929       {
14930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14931       };
14932     }
14933   }
14934   jresult = (void *)result;
14935   return jresult;
14936 }
14937
14938
14939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
14940   void * jresult ;
14941   Dali::Vector4 *arg1 = 0 ;
14942   Dali::Property::Value *result = 0 ;
14943
14944   arg1 = (Dali::Vector4 *)jarg1;
14945   if (!arg1) {
14946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
14947     return 0;
14948   }
14949   {
14950     try {
14951       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
14952     } catch (std::out_of_range& e) {
14953       {
14954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14955       };
14956     } catch (std::exception& e) {
14957       {
14958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14959       };
14960     } catch (...) {
14961       {
14962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14963       };
14964     }
14965   }
14966   jresult = (void *)result;
14967   return jresult;
14968 }
14969
14970
14971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
14972   void * jresult ;
14973   Dali::Matrix3 *arg1 = 0 ;
14974   Dali::Property::Value *result = 0 ;
14975
14976   arg1 = (Dali::Matrix3 *)jarg1;
14977   if (!arg1) {
14978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
14979     return 0;
14980   }
14981   {
14982     try {
14983       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
14984     } catch (std::out_of_range& e) {
14985       {
14986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14987       };
14988     } catch (std::exception& e) {
14989       {
14990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14991       };
14992     } catch (...) {
14993       {
14994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14995       };
14996     }
14997   }
14998   jresult = (void *)result;
14999   return jresult;
15000 }
15001
15002
15003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
15004   void * jresult ;
15005   Dali::Matrix *arg1 = 0 ;
15006   Dali::Property::Value *result = 0 ;
15007
15008   arg1 = (Dali::Matrix *)jarg1;
15009   if (!arg1) {
15010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
15011     return 0;
15012   }
15013   {
15014     try {
15015       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
15016     } catch (std::out_of_range& e) {
15017       {
15018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15019       };
15020     } catch (std::exception& e) {
15021       {
15022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15023       };
15024     } catch (...) {
15025       {
15026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15027       };
15028     }
15029   }
15030   jresult = (void *)result;
15031   return jresult;
15032 }
15033
15034
15035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
15036   void * jresult ;
15037   Dali::Rect< int > *arg1 = 0 ;
15038   Dali::Property::Value *result = 0 ;
15039
15040   arg1 = (Dali::Rect< int > *)jarg1;
15041   if (!arg1) {
15042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
15043     return 0;
15044   }
15045   {
15046     try {
15047       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
15048     } catch (std::out_of_range& e) {
15049       {
15050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15051       };
15052     } catch (std::exception& e) {
15053       {
15054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15055       };
15056     } catch (...) {
15057       {
15058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15059       };
15060     }
15061   }
15062   jresult = (void *)result;
15063   return jresult;
15064 }
15065
15066
15067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
15068   void * jresult ;
15069   Dali::AngleAxis *arg1 = 0 ;
15070   Dali::Property::Value *result = 0 ;
15071
15072   arg1 = (Dali::AngleAxis *)jarg1;
15073   if (!arg1) {
15074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
15075     return 0;
15076   }
15077   {
15078     try {
15079       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
15080     } catch (std::out_of_range& e) {
15081       {
15082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15083       };
15084     } catch (std::exception& e) {
15085       {
15086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15087       };
15088     } catch (...) {
15089       {
15090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15091       };
15092     }
15093   }
15094   jresult = (void *)result;
15095   return jresult;
15096 }
15097
15098
15099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
15100   void * jresult ;
15101   Dali::Quaternion *arg1 = 0 ;
15102   Dali::Property::Value *result = 0 ;
15103
15104   arg1 = (Dali::Quaternion *)jarg1;
15105   if (!arg1) {
15106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
15107     return 0;
15108   }
15109   {
15110     try {
15111       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
15112     } catch (std::out_of_range& e) {
15113       {
15114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15115       };
15116     } catch (std::exception& e) {
15117       {
15118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15119       };
15120     } catch (...) {
15121       {
15122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15123       };
15124     }
15125   }
15126   jresult = (void *)result;
15127   return jresult;
15128 }
15129
15130
15131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
15132   void * jresult ;
15133   std::string *arg1 = 0 ;
15134   Dali::Property::Value *result = 0 ;
15135
15136   if (!jarg1) {
15137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15138     return 0;
15139   }
15140   std::string arg1_str(jarg1);
15141   arg1 = &arg1_str;
15142   {
15143     try {
15144       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
15145     } catch (std::out_of_range& e) {
15146       {
15147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15148       };
15149     } catch (std::exception& e) {
15150       {
15151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15152       };
15153     } catch (...) {
15154       {
15155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15156       };
15157     }
15158   }
15159   jresult = (void *)result;
15160
15161   //argout typemap for const std::string&
15162
15163   return jresult;
15164 }
15165
15166
15167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
15168   void * jresult ;
15169   Dali::Property::Array *arg1 = 0 ;
15170   Dali::Property::Value *result = 0 ;
15171
15172   arg1 = (Dali::Property::Array *)jarg1;
15173   if (!arg1) {
15174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15175     return 0;
15176   }
15177   {
15178     try {
15179       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15180     } catch (std::out_of_range& e) {
15181       {
15182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15183       };
15184     } catch (std::exception& e) {
15185       {
15186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15187       };
15188     } catch (...) {
15189       {
15190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15191       };
15192     }
15193   }
15194   jresult = (void *)result;
15195   return jresult;
15196 }
15197
15198
15199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
15200   void * jresult ;
15201   Dali::Property::Map *arg1 = 0 ;
15202   Dali::Property::Value *result = 0 ;
15203
15204   arg1 = (Dali::Property::Map *)jarg1;
15205   if (!arg1) {
15206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15207     return 0;
15208   }
15209   {
15210     try {
15211       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15212     } catch (std::out_of_range& e) {
15213       {
15214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15215       };
15216     } catch (std::exception& e) {
15217       {
15218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15219       };
15220     } catch (...) {
15221       {
15222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15223       };
15224     }
15225   }
15226   jresult = (void *)result;
15227   return jresult;
15228 }
15229
15230
15231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(int jarg1) {
15232   void * jresult ;
15233   Dali::Property::Type arg1 ;
15234   Dali::Property::Value *result = 0 ;
15235
15236   arg1 = (Dali::Property::Type)jarg1;
15237   {
15238     try {
15239       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
15240     } catch (std::out_of_range& e) {
15241       {
15242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15243       };
15244     } catch (std::exception& e) {
15245       {
15246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15247       };
15248     } catch (...) {
15249       {
15250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15251       };
15252     }
15253   }
15254   jresult = (void *)result;
15255   return jresult;
15256 }
15257
15258
15259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(void * jarg1) {
15260   void * jresult ;
15261   Dali::Property::Value *arg1 = 0 ;
15262   Dali::Property::Value *result = 0 ;
15263
15264   arg1 = (Dali::Property::Value *)jarg1;
15265   if (!arg1) {
15266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15267     return 0;
15268   }
15269   {
15270     try {
15271       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
15272     } catch (std::out_of_range& e) {
15273       {
15274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15275       };
15276     } catch (std::exception& e) {
15277       {
15278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15279       };
15280     } catch (...) {
15281       {
15282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15283       };
15284     }
15285   }
15286   jresult = (void *)result;
15287   return jresult;
15288 }
15289
15290
15291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
15292   void * jresult ;
15293   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15294   Dali::Property::Value *arg2 = 0 ;
15295   Dali::Property::Value *result = 0 ;
15296
15297   arg1 = (Dali::Property::Value *)jarg1;
15298   arg2 = (Dali::Property::Value *)jarg2;
15299   if (!arg2) {
15300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15301     return 0;
15302   }
15303   {
15304     try {
15305       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
15306     } catch (std::out_of_range& e) {
15307       {
15308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15309       };
15310     } catch (std::exception& e) {
15311       {
15312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15313       };
15314     } catch (...) {
15315       {
15316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15317       };
15318     }
15319   }
15320   jresult = (void *)result;
15321   return jresult;
15322 }
15323
15324
15325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
15326   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15327
15328   arg1 = (Dali::Property::Value *)jarg1;
15329   {
15330     try {
15331       delete arg1;
15332     } catch (std::out_of_range& e) {
15333       {
15334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15335       };
15336     } catch (std::exception& e) {
15337       {
15338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15339       };
15340     } catch (...) {
15341       {
15342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15343       };
15344     }
15345   }
15346 }
15347
15348
15349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
15350   int jresult ;
15351   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15352   Dali::Property::Type result;
15353
15354   arg1 = (Dali::Property::Value *)jarg1;
15355   {
15356     try {
15357       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
15358     } catch (std::out_of_range& e) {
15359       {
15360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15361       };
15362     } catch (std::exception& e) {
15363       {
15364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15365       };
15366     } catch (...) {
15367       {
15368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15369       };
15370     }
15371   }
15372   jresult = (int)result;
15373   return jresult;
15374 }
15375
15376
15377 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
15378   unsigned int jresult ;
15379   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15380   bool *arg2 = 0 ;
15381   bool result;
15382
15383   arg1 = (Dali::Property::Value *)jarg1;
15384   arg2 = (bool *)jarg2;
15385   {
15386     try {
15387       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15388     } catch (std::out_of_range& e) {
15389       {
15390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15391       };
15392     } catch (std::exception& e) {
15393       {
15394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15395       };
15396     } catch (...) {
15397       {
15398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15399       };
15400     }
15401   }
15402   jresult = result;
15403   return jresult;
15404 }
15405
15406
15407 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
15408   unsigned int jresult ;
15409   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15410   float *arg2 = 0 ;
15411   bool result;
15412
15413   arg1 = (Dali::Property::Value *)jarg1;
15414   arg2 = (float *)jarg2;
15415   {
15416     try {
15417       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15418     } catch (std::out_of_range& e) {
15419       {
15420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15421       };
15422     } catch (std::exception& e) {
15423       {
15424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15425       };
15426     } catch (...) {
15427       {
15428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15429       };
15430     }
15431   }
15432   jresult = result;
15433   return jresult;
15434 }
15435
15436
15437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
15438   unsigned int jresult ;
15439   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15440   int *arg2 = 0 ;
15441   bool result;
15442
15443   arg1 = (Dali::Property::Value *)jarg1;
15444   arg2 = (int *)jarg2;
15445   {
15446     try {
15447       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15448     } catch (std::out_of_range& e) {
15449       {
15450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15451       };
15452     } catch (std::exception& e) {
15453       {
15454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15455       };
15456     } catch (...) {
15457       {
15458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15459       };
15460     }
15461   }
15462   jresult = result;
15463   return jresult;
15464 }
15465
15466
15467 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
15468   unsigned int jresult ;
15469   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15470   Dali::Rect< int > *arg2 = 0 ;
15471   bool result;
15472
15473   arg1 = (Dali::Property::Value *)jarg1;
15474   arg2 = (Dali::Rect< int > *)jarg2;
15475   if (!arg2) {
15476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
15477     return 0;
15478   }
15479   {
15480     try {
15481       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15482     } catch (std::out_of_range& e) {
15483       {
15484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15485       };
15486     } catch (std::exception& e) {
15487       {
15488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15489       };
15490     } catch (...) {
15491       {
15492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15493       };
15494     }
15495   }
15496   jresult = result;
15497   return jresult;
15498 }
15499
15500
15501 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
15502   unsigned int jresult ;
15503   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15504   Dali::Vector2 *arg2 = 0 ;
15505   bool result;
15506
15507   arg1 = (Dali::Property::Value *)jarg1;
15508   arg2 = (Dali::Vector2 *)jarg2;
15509   if (!arg2) {
15510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
15511     return 0;
15512   }
15513   {
15514     try {
15515       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15516     } catch (std::out_of_range& e) {
15517       {
15518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15519       };
15520     } catch (std::exception& e) {
15521       {
15522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15523       };
15524     } catch (...) {
15525       {
15526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15527       };
15528     }
15529   }
15530   jresult = result;
15531   return jresult;
15532 }
15533
15534
15535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
15536   unsigned int jresult ;
15537   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15538   Dali::Vector3 *arg2 = 0 ;
15539   bool result;
15540
15541   arg1 = (Dali::Property::Value *)jarg1;
15542   arg2 = (Dali::Vector3 *)jarg2;
15543   if (!arg2) {
15544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
15545     return 0;
15546   }
15547   {
15548     try {
15549       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15550     } catch (std::out_of_range& e) {
15551       {
15552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15553       };
15554     } catch (std::exception& e) {
15555       {
15556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15557       };
15558     } catch (...) {
15559       {
15560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15561       };
15562     }
15563   }
15564   jresult = result;
15565   return jresult;
15566 }
15567
15568
15569 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
15570   unsigned int jresult ;
15571   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15572   Dali::Vector4 *arg2 = 0 ;
15573   bool result;
15574
15575   arg1 = (Dali::Property::Value *)jarg1;
15576   arg2 = (Dali::Vector4 *)jarg2;
15577   if (!arg2) {
15578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
15579     return 0;
15580   }
15581   {
15582     try {
15583       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15584     } catch (std::out_of_range& e) {
15585       {
15586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15587       };
15588     } catch (std::exception& e) {
15589       {
15590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15591       };
15592     } catch (...) {
15593       {
15594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15595       };
15596     }
15597   }
15598   jresult = result;
15599   return jresult;
15600 }
15601
15602
15603 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
15604   unsigned int jresult ;
15605   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15606   Dali::Matrix3 *arg2 = 0 ;
15607   bool result;
15608
15609   arg1 = (Dali::Property::Value *)jarg1;
15610   arg2 = (Dali::Matrix3 *)jarg2;
15611   if (!arg2) {
15612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
15613     return 0;
15614   }
15615   {
15616     try {
15617       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15618     } catch (std::out_of_range& e) {
15619       {
15620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15621       };
15622     } catch (std::exception& e) {
15623       {
15624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15625       };
15626     } catch (...) {
15627       {
15628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15629       };
15630     }
15631   }
15632   jresult = result;
15633   return jresult;
15634 }
15635
15636
15637 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
15638   unsigned int jresult ;
15639   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15640   Dali::Matrix *arg2 = 0 ;
15641   bool result;
15642
15643   arg1 = (Dali::Property::Value *)jarg1;
15644   arg2 = (Dali::Matrix *)jarg2;
15645   if (!arg2) {
15646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
15647     return 0;
15648   }
15649   {
15650     try {
15651       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15652     } catch (std::out_of_range& e) {
15653       {
15654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15655       };
15656     } catch (std::exception& e) {
15657       {
15658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15659       };
15660     } catch (...) {
15661       {
15662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15663       };
15664     }
15665   }
15666   jresult = result;
15667   return jresult;
15668 }
15669
15670
15671 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
15672   unsigned int jresult ;
15673   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15674   Dali::AngleAxis *arg2 = 0 ;
15675   bool result;
15676
15677   arg1 = (Dali::Property::Value *)jarg1;
15678   arg2 = (Dali::AngleAxis *)jarg2;
15679   if (!arg2) {
15680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
15681     return 0;
15682   }
15683   {
15684     try {
15685       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15686     } catch (std::out_of_range& e) {
15687       {
15688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15689       };
15690     } catch (std::exception& e) {
15691       {
15692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15693       };
15694     } catch (...) {
15695       {
15696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15697       };
15698     }
15699   }
15700   jresult = result;
15701   return jresult;
15702 }
15703
15704
15705 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
15706   unsigned int jresult ;
15707   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15708   Dali::Quaternion *arg2 = 0 ;
15709   bool result;
15710
15711   arg1 = (Dali::Property::Value *)jarg1;
15712   arg2 = (Dali::Quaternion *)jarg2;
15713   if (!arg2) {
15714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
15715     return 0;
15716   }
15717   {
15718     try {
15719       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15720     } catch (std::out_of_range& e) {
15721       {
15722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15723       };
15724     } catch (std::exception& e) {
15725       {
15726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15727       };
15728     } catch (...) {
15729       {
15730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15731       };
15732     }
15733   }
15734   jresult = result;
15735   return jresult;
15736 }
15737
15738
15739 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
15740   unsigned int jresult ;
15741   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15742   std::string *arg2 = 0 ;
15743   bool result;
15744
15745   arg1 = (Dali::Property::Value *)jarg1;
15746
15747   //typemap in
15748   std::string temp;
15749   arg2 = &temp;
15750
15751   {
15752     try {
15753       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15754     } catch (std::out_of_range& e) {
15755       {
15756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15757       };
15758     } catch (std::exception& e) {
15759       {
15760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15761       };
15762     } catch (...) {
15763       {
15764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15765       };
15766     }
15767   }
15768   jresult = result;
15769
15770   //Typemap argout in c++ file.
15771   //This will convert c++ string to c# string
15772   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
15773
15774   return jresult;
15775 }
15776
15777
15778 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
15779   unsigned int jresult ;
15780   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15781   Dali::Property::Array *arg2 = 0 ;
15782   bool result;
15783
15784   arg1 = (Dali::Property::Value *)jarg1;
15785   arg2 = (Dali::Property::Array *)jarg2;
15786   if (!arg2) {
15787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15788     return 0;
15789   }
15790   {
15791     try {
15792       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15793     } catch (std::out_of_range& e) {
15794       {
15795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15796       };
15797     } catch (std::exception& e) {
15798       {
15799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15800       };
15801     } catch (...) {
15802       {
15803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15804       };
15805     }
15806   }
15807   jresult = result;
15808   return jresult;
15809 }
15810
15811
15812 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
15813   unsigned int jresult ;
15814   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15815   Dali::Property::Map *arg2 = 0 ;
15816   bool result;
15817
15818   arg1 = (Dali::Property::Value *)jarg1;
15819   arg2 = (Dali::Property::Map *)jarg2;
15820   if (!arg2) {
15821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15822     return 0;
15823   }
15824   {
15825     try {
15826       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15827     } catch (std::out_of_range& e) {
15828       {
15829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15830       };
15831     } catch (std::exception& e) {
15832       {
15833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15834       };
15835     } catch (...) {
15836       {
15837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15838       };
15839     }
15840   }
15841   jresult = result;
15842   return jresult;
15843 }
15844
15845
15846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
15847   void * jresult ;
15848   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15849   Dali::Property::Array *result = 0 ;
15850
15851   arg1 = (Dali::Property::Value *)jarg1;
15852   {
15853     try {
15854       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
15855     } catch (std::out_of_range& e) {
15856       {
15857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15858       };
15859     } catch (std::exception& e) {
15860       {
15861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15862       };
15863     } catch (...) {
15864       {
15865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15866       };
15867     }
15868   }
15869   jresult = (void *)result;
15870   return jresult;
15871 }
15872
15873
15874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
15875   void * jresult ;
15876   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15877   Dali::Property::Map *result = 0 ;
15878
15879   arg1 = (Dali::Property::Value *)jarg1;
15880   {
15881     try {
15882       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
15883     } catch (std::out_of_range& e) {
15884       {
15885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15886       };
15887     } catch (std::exception& e) {
15888       {
15889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15890       };
15891     } catch (...) {
15892       {
15893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15894       };
15895     }
15896   }
15897   jresult = (void *)result;
15898   return jresult;
15899 }
15900
15901
15902 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
15903   char * jresult ;
15904   Dali::Property::Type arg1 ;
15905   char *result = 0 ;
15906
15907   arg1 = (Dali::Property::Type)jarg1;
15908   {
15909     try {
15910       result = (char *)Dali::PropertyTypes::GetName(arg1);
15911     } catch (std::out_of_range& e) {
15912       {
15913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15914       };
15915     } catch (std::exception& e) {
15916       {
15917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15918       };
15919     } catch (...) {
15920       {
15921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15922       };
15923     }
15924   }
15925   jresult = SWIG_csharp_string_callback((const char *)result);
15926   return jresult;
15927 }
15928
15929
15930 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
15931   unsigned int jresult ;
15932   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15933   std::string *arg2 = 0 ;
15934   Dali::Property::Map *arg3 = 0 ;
15935   bool result;
15936
15937   arg1 = (Dali::BaseObject *)jarg1;
15938   if (!jarg2) {
15939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15940     return 0;
15941   }
15942   std::string arg2_str(jarg2);
15943   arg2 = &arg2_str;
15944   arg3 = (Dali::Property::Map *)jarg3;
15945   if (!arg3) {
15946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15947     return 0;
15948   }
15949   {
15950     try {
15951       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
15952     } catch (std::out_of_range& e) {
15953       {
15954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15955       };
15956     } catch (std::exception& e) {
15957       {
15958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15959       };
15960     } catch (...) {
15961       {
15962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15963       };
15964     }
15965   }
15966   jresult = result;
15967
15968   //argout typemap for const std::string&
15969
15970   return jresult;
15971 }
15972
15973
15974 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
15975   char * jresult ;
15976   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15977   std::string *result = 0 ;
15978
15979   arg1 = (Dali::BaseObject *)jarg1;
15980   {
15981     try {
15982       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
15983     } catch (std::out_of_range& e) {
15984       {
15985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15986       };
15987     } catch (std::exception& e) {
15988       {
15989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15990       };
15991     } catch (...) {
15992       {
15993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15994       };
15995     }
15996   }
15997   jresult = SWIG_csharp_string_callback(result->c_str());
15998   return jresult;
15999 }
16000
16001
16002 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
16003   unsigned int jresult ;
16004   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16005   Dali::TypeInfo *arg2 = 0 ;
16006   bool result;
16007
16008   arg1 = (Dali::BaseObject *)jarg1;
16009   arg2 = (Dali::TypeInfo *)jarg2;
16010   if (!arg2) {
16011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16012     return 0;
16013   }
16014   {
16015     try {
16016       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
16017     } catch (std::out_of_range& e) {
16018       {
16019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16020       };
16021     } catch (std::exception& e) {
16022       {
16023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16024       };
16025     } catch (...) {
16026       {
16027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16028       };
16029     }
16030   }
16031   jresult = result;
16032   return jresult;
16033 }
16034
16035
16036 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
16037   unsigned int jresult ;
16038   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16039   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
16040   std::string *arg3 = 0 ;
16041   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
16042   bool result;
16043
16044   arg1 = (Dali::BaseObject *)jarg1;
16045   arg2 = (ConnectionTrackerInterface *)jarg2;
16046   if (!jarg3) {
16047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16048     return 0;
16049   }
16050   std::string arg3_str(jarg3);
16051   arg3 = &arg3_str;
16052   arg4 = (FunctorDelegate *)jarg4;
16053   {
16054     try {
16055       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
16056     } catch (std::out_of_range& e) {
16057       {
16058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16059       };
16060     } catch (std::exception& e) {
16061       {
16062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16063       };
16064     } catch (...) {
16065       {
16066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16067       };
16068     }
16069   }
16070   jresult = result;
16071
16072   //argout typemap for const std::string&
16073
16074   return jresult;
16075 }
16076
16077
16078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
16079   void * jresult ;
16080   Dali::BaseHandle *arg1 = 0 ;
16081   Dali::BaseObject *result = 0 ;
16082
16083   arg1 = (Dali::BaseHandle *)jarg1;
16084   if (!arg1) {
16085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16086     return 0;
16087   }
16088   {
16089     try {
16090       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
16091     } catch (std::out_of_range& e) {
16092       {
16093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16094       };
16095     } catch (std::exception& e) {
16096       {
16097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16098       };
16099     } catch (...) {
16100       {
16101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16102       };
16103     }
16104   }
16105   jresult = (void *)result;
16106   return jresult;
16107 }
16108
16109
16110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
16111   void * jresult ;
16112   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16113   Dali::BaseHandle *result = 0 ;
16114
16115   arg1 = (Dali::BaseObject *)jarg1;
16116   {
16117     try {
16118       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
16119     } catch (std::out_of_range& e) {
16120       {
16121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16122       };
16123     } catch (std::exception& e) {
16124       {
16125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16126       };
16127     } catch (...) {
16128       {
16129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16130       };
16131     }
16132   }
16133   jresult = (void *)result;
16134   return jresult;
16135 }
16136
16137
16138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
16139   void * jresult ;
16140   Dali::BaseHandle *result = 0 ;
16141
16142   {
16143     try {
16144       result = (Dali::BaseHandle *)new Dali::BaseHandle();
16145     } catch (std::out_of_range& e) {
16146       {
16147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16148       };
16149     } catch (std::exception& e) {
16150       {
16151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16152       };
16153     } catch (...) {
16154       {
16155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16156       };
16157     }
16158   }
16159   jresult = (void *)result;
16160   return jresult;
16161 }
16162
16163
16164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
16165   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16166
16167   arg1 = (Dali::BaseHandle *)jarg1;
16168   {
16169     try {
16170       delete arg1;
16171     } catch (std::out_of_range& e) {
16172       {
16173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16174       };
16175     } catch (std::exception& e) {
16176       {
16177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16178       };
16179     } catch (...) {
16180       {
16181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16182       };
16183     }
16184   }
16185 }
16186
16187
16188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
16189   void * jresult ;
16190   Dali::BaseHandle *arg1 = 0 ;
16191   Dali::BaseHandle *result = 0 ;
16192
16193   arg1 = (Dali::BaseHandle *)jarg1;
16194   if (!arg1) {
16195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16196     return 0;
16197   }
16198   {
16199     try {
16200       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
16201     } catch (std::out_of_range& e) {
16202       {
16203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16204       };
16205     } catch (std::exception& e) {
16206       {
16207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16208       };
16209     } catch (...) {
16210       {
16211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16212       };
16213     }
16214   }
16215   jresult = (void *)result;
16216   return jresult;
16217 }
16218
16219
16220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
16221   void * jresult ;
16222   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16223   Dali::BaseHandle *arg2 = 0 ;
16224   Dali::BaseHandle *result = 0 ;
16225
16226   arg1 = (Dali::BaseHandle *)jarg1;
16227   arg2 = (Dali::BaseHandle *)jarg2;
16228   if (!arg2) {
16229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16230     return 0;
16231   }
16232   {
16233     try {
16234       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
16235     } catch (std::out_of_range& e) {
16236       {
16237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16238       };
16239     } catch (std::exception& e) {
16240       {
16241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16242       };
16243     } catch (...) {
16244       {
16245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16246       };
16247     }
16248   }
16249   jresult = (void *)result;
16250   return jresult;
16251 }
16252
16253
16254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
16255   unsigned int jresult ;
16256   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16257   std::string *arg2 = 0 ;
16258   Dali::Property::Map *arg3 = 0 ;
16259   bool result;
16260
16261   arg1 = (Dali::BaseHandle *)jarg1;
16262   if (!jarg2) {
16263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16264     return 0;
16265   }
16266   std::string arg2_str(jarg2);
16267   arg2 = &arg2_str;
16268   arg3 = (Dali::Property::Map *)jarg3;
16269   if (!arg3) {
16270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16271     return 0;
16272   }
16273   {
16274     try {
16275       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
16276     } catch (std::out_of_range& e) {
16277       {
16278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16279       };
16280     } catch (std::exception& e) {
16281       {
16282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16283       };
16284     } catch (...) {
16285       {
16286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16287       };
16288     }
16289   }
16290   jresult = result;
16291
16292   //argout typemap for const std::string&
16293
16294   return jresult;
16295 }
16296
16297
16298 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
16299   char * jresult ;
16300   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16301   std::string *result = 0 ;
16302
16303   arg1 = (Dali::BaseHandle *)jarg1;
16304   {
16305     try {
16306       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
16307     } catch (std::out_of_range& e) {
16308       {
16309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16310       };
16311     } catch (std::exception& e) {
16312       {
16313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16314       };
16315     } catch (...) {
16316       {
16317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16318       };
16319     }
16320   }
16321   jresult = SWIG_csharp_string_callback(result->c_str());
16322   return jresult;
16323 }
16324
16325
16326 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
16327   unsigned int jresult ;
16328   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16329   Dali::TypeInfo *arg2 = 0 ;
16330   bool result;
16331
16332   arg1 = (Dali::BaseHandle *)jarg1;
16333   arg2 = (Dali::TypeInfo *)jarg2;
16334   if (!arg2) {
16335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16336     return 0;
16337   }
16338   {
16339     try {
16340       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
16341     } catch (std::out_of_range& e) {
16342       {
16343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16344       };
16345     } catch (std::exception& e) {
16346       {
16347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16348       };
16349     } catch (...) {
16350       {
16351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16352       };
16353     }
16354   }
16355   jresult = result;
16356   return jresult;
16357 }
16358
16359
16360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
16361   void * jresult ;
16362   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16363   Dali::BaseObject *result = 0 ;
16364
16365   arg1 = (Dali::BaseHandle *)jarg1;
16366   {
16367     try {
16368       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
16369     } catch (std::out_of_range& e) {
16370       {
16371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16372       };
16373     } catch (std::exception& e) {
16374       {
16375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16376       };
16377     } catch (...) {
16378       {
16379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16380       };
16381     }
16382   }
16383   jresult = (void *)result;
16384   return jresult;
16385 }
16386
16387
16388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
16389   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16390
16391   arg1 = (Dali::BaseHandle *)jarg1;
16392   {
16393     try {
16394       (arg1)->Reset();
16395     } catch (std::out_of_range& e) {
16396       {
16397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16398       };
16399     } catch (std::exception& e) {
16400       {
16401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16402       };
16403     } catch (...) {
16404       {
16405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16406       };
16407     }
16408   }
16409 }
16410
16411
16412 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
16413   unsigned int jresult ;
16414   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16415   Dali::BaseHandle *arg2 = 0 ;
16416   bool result;
16417
16418   arg1 = (Dali::BaseHandle *)jarg1;
16419   arg2 = (Dali::BaseHandle *)jarg2;
16420   if (!arg2) {
16421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16422     return 0;
16423   }
16424   {
16425     try {
16426       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
16427     } catch (std::out_of_range& e) {
16428       {
16429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16430       };
16431     } catch (std::exception& e) {
16432       {
16433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16434       };
16435     } catch (...) {
16436       {
16437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16438       };
16439     }
16440   }
16441   jresult = result;
16442   return jresult;
16443 }
16444
16445
16446 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
16447   unsigned int jresult ;
16448   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16449   Dali::BaseHandle *arg2 = 0 ;
16450   bool result;
16451
16452   arg1 = (Dali::BaseHandle *)jarg1;
16453   arg2 = (Dali::BaseHandle *)jarg2;
16454   if (!arg2) {
16455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16456     return 0;
16457   }
16458   {
16459     try {
16460       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
16461     } catch (std::out_of_range& e) {
16462       {
16463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16464       };
16465     } catch (std::exception& e) {
16466       {
16467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16468       };
16469     } catch (...) {
16470       {
16471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16472       };
16473     }
16474   }
16475   jresult = result;
16476   return jresult;
16477 }
16478
16479
16480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
16481   void * jresult ;
16482   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16483   Dali::RefObject *result = 0 ;
16484
16485   arg1 = (Dali::BaseHandle *)jarg1;
16486   {
16487     try {
16488       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
16489     } catch (std::out_of_range& e) {
16490       {
16491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16492       };
16493     } catch (std::exception& e) {
16494       {
16495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16496       };
16497     } catch (...) {
16498       {
16499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16500       };
16501     }
16502   }
16503   jresult = (void *)result;
16504   return jresult;
16505 }
16506
16507
16508 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
16509   unsigned int jresult ;
16510   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16511   bool result;
16512
16513   arg1 = (Dali::BaseHandle *)jarg1;
16514   {
16515     try {
16516       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
16517     } catch (std::out_of_range& e) {
16518       {
16519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16520       };
16521     } catch (std::exception& e) {
16522       {
16523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16524       };
16525     } catch (...) {
16526       {
16527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16528       };
16529     }
16530   }
16531   jresult = result;
16532   return jresult;
16533 }
16534
16535
16536 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
16537   unsigned int jresult ;
16538   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16539   Dali::BaseHandle *arg2 = 0 ;
16540   bool result;
16541
16542   arg1 = (Dali::BaseHandle *)jarg1;
16543   arg2 = (Dali::BaseHandle *)jarg2;
16544   if (!arg2) {
16545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16546     return 0;
16547   }
16548   {
16549     try {
16550       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
16551     } catch (std::out_of_range& e) {
16552       {
16553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16554       };
16555     } catch (std::exception& e) {
16556       {
16557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16558       };
16559     } catch (...) {
16560       {
16561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16562       };
16563     }
16564   }
16565   jresult = result;
16566   return jresult;
16567 }
16568
16569
16570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
16571   unsigned int jresult ;
16572   Dali::BaseHandle *arg1 = 0 ;
16573   Dali::BaseHandle *arg2 = 0 ;
16574   bool result;
16575
16576   arg1 = (Dali::BaseHandle *)jarg1;
16577   if (!arg1) {
16578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16579     return 0;
16580   }
16581   arg2 = (Dali::BaseHandle *)jarg2;
16582   if (!arg2) {
16583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16584     return 0;
16585   }
16586   {
16587     try {
16588       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
16589     } catch (std::out_of_range& e) {
16590       {
16591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16592       };
16593     } catch (std::exception& e) {
16594       {
16595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16596       };
16597     } catch (...) {
16598       {
16599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16600       };
16601     }
16602   }
16603   jresult = result;
16604   return jresult;
16605 }
16606
16607
16608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
16609   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16610
16611   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16612   {
16613     try {
16614       delete arg1;
16615     } catch (std::out_of_range& e) {
16616       {
16617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16618       };
16619     } catch (std::exception& e) {
16620       {
16621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16622       };
16623     } catch (...) {
16624       {
16625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16626       };
16627     }
16628   }
16629 }
16630
16631
16632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16633   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16634   SlotObserver *arg2 = (SlotObserver *) 0 ;
16635   CallbackBase *arg3 = (CallbackBase *) 0 ;
16636
16637   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16638   arg2 = (SlotObserver *)jarg2;
16639   arg3 = (CallbackBase *)jarg3;
16640   {
16641     try {
16642       (arg1)->SignalConnected(arg2,arg3);
16643     } catch (std::out_of_range& e) {
16644       {
16645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16646       };
16647     } catch (std::exception& e) {
16648       {
16649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16650       };
16651     } catch (...) {
16652       {
16653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16654       };
16655     }
16656   }
16657 }
16658
16659
16660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
16661   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16662
16663   arg1 = (Dali::SignalObserver *)jarg1;
16664   {
16665     try {
16666       delete arg1;
16667     } catch (std::out_of_range& e) {
16668       {
16669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16670       };
16671     } catch (std::exception& e) {
16672       {
16673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16674       };
16675     } catch (...) {
16676       {
16677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16678       };
16679     }
16680   }
16681 }
16682
16683
16684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16685   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16686   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16687   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16688
16689   arg1 = (Dali::SignalObserver *)jarg1;
16690   arg2 = (Dali::SlotObserver *)jarg2;
16691   arg3 = (Dali::CallbackBase *)jarg3;
16692   {
16693     try {
16694       (arg1)->SignalDisconnected(arg2,arg3);
16695     } catch (std::out_of_range& e) {
16696       {
16697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16698       };
16699     } catch (std::exception& e) {
16700       {
16701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16702       };
16703     } catch (...) {
16704       {
16705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16706       };
16707     }
16708   }
16709 }
16710
16711
16712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
16713   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16714
16715   arg1 = (Dali::SlotObserver *)jarg1;
16716   {
16717     try {
16718       delete arg1;
16719     } catch (std::out_of_range& e) {
16720       {
16721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16722       };
16723     } catch (std::exception& e) {
16724       {
16725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16726       };
16727     } catch (...) {
16728       {
16729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16730       };
16731     }
16732   }
16733 }
16734
16735
16736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
16737   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16738   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
16739
16740   arg1 = (Dali::SlotObserver *)jarg1;
16741   arg2 = (Dali::CallbackBase *)jarg2;
16742   {
16743     try {
16744       (arg1)->SlotDisconnected(arg2);
16745     } catch (std::out_of_range& e) {
16746       {
16747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16748       };
16749     } catch (std::exception& e) {
16750       {
16751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16752       };
16753     } catch (...) {
16754       {
16755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16756       };
16757     }
16758   }
16759 }
16760
16761
16762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
16763   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16764
16765   arg1 = (Dali::ConnectionTracker *)jarg1;
16766   {
16767     try {
16768       delete arg1;
16769     } catch (std::out_of_range& e) {
16770       {
16771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16772       };
16773     } catch (std::exception& e) {
16774       {
16775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16776       };
16777     } catch (...) {
16778       {
16779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16780       };
16781     }
16782   }
16783 }
16784
16785
16786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
16787   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16788
16789   arg1 = (Dali::ConnectionTracker *)jarg1;
16790   {
16791     try {
16792       (arg1)->DisconnectAll();
16793     } catch (std::out_of_range& e) {
16794       {
16795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16796       };
16797     } catch (std::exception& e) {
16798       {
16799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16800       };
16801     } catch (...) {
16802       {
16803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16804       };
16805     }
16806   }
16807 }
16808
16809
16810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16811   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16812   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16813   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16814
16815   arg1 = (Dali::ConnectionTracker *)jarg1;
16816   arg2 = (Dali::SlotObserver *)jarg2;
16817   arg3 = (Dali::CallbackBase *)jarg3;
16818   {
16819     try {
16820       (arg1)->SignalConnected(arg2,arg3);
16821     } catch (std::out_of_range& e) {
16822       {
16823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16824       };
16825     } catch (std::exception& e) {
16826       {
16827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16828       };
16829     } catch (...) {
16830       {
16831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16832       };
16833     }
16834   }
16835 }
16836
16837
16838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16839   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16840   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16841   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16842
16843   arg1 = (Dali::ConnectionTracker *)jarg1;
16844   arg2 = (Dali::SlotObserver *)jarg2;
16845   arg3 = (Dali::CallbackBase *)jarg3;
16846   {
16847     try {
16848       (arg1)->SignalDisconnected(arg2,arg3);
16849     } catch (std::out_of_range& e) {
16850       {
16851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16852       };
16853     } catch (std::exception& e) {
16854       {
16855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16856       };
16857     } catch (...) {
16858       {
16859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16860       };
16861     }
16862   }
16863 }
16864
16865
16866 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
16867   unsigned long jresult ;
16868   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16869   std::size_t result;
16870
16871   arg1 = (Dali::ConnectionTracker *)jarg1;
16872   {
16873     try {
16874       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
16875     } catch (std::out_of_range& e) {
16876       {
16877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16878       };
16879     } catch (std::exception& e) {
16880       {
16881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16882       };
16883     } catch (...) {
16884       {
16885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16886       };
16887     }
16888   }
16889   jresult = (unsigned long)result;
16890   return jresult;
16891 }
16892
16893
16894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
16895   void * jresult ;
16896   Dali::ObjectRegistry *result = 0 ;
16897
16898   {
16899     try {
16900       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
16901     } catch (std::out_of_range& e) {
16902       {
16903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16904       };
16905     } catch (std::exception& e) {
16906       {
16907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16908       };
16909     } catch (...) {
16910       {
16911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16912       };
16913     }
16914   }
16915   jresult = (void *)result;
16916   return jresult;
16917 }
16918
16919
16920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
16921   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16922
16923   arg1 = (Dali::ObjectRegistry *)jarg1;
16924   {
16925     try {
16926       delete arg1;
16927     } catch (std::out_of_range& e) {
16928       {
16929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16930       };
16931     } catch (std::exception& e) {
16932       {
16933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16934       };
16935     } catch (...) {
16936       {
16937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16938       };
16939     }
16940   }
16941 }
16942
16943
16944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
16945   void * jresult ;
16946   Dali::ObjectRegistry *arg1 = 0 ;
16947   Dali::ObjectRegistry *result = 0 ;
16948
16949   arg1 = (Dali::ObjectRegistry *)jarg1;
16950   if (!arg1) {
16951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16952     return 0;
16953   }
16954   {
16955     try {
16956       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
16957     } catch (std::out_of_range& e) {
16958       {
16959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16960       };
16961     } catch (std::exception& e) {
16962       {
16963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16964       };
16965     } catch (...) {
16966       {
16967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16968       };
16969     }
16970   }
16971   jresult = (void *)result;
16972   return jresult;
16973 }
16974
16975
16976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
16977   void * jresult ;
16978   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16979   Dali::ObjectRegistry *arg2 = 0 ;
16980   Dali::ObjectRegistry *result = 0 ;
16981
16982   arg1 = (Dali::ObjectRegistry *)jarg1;
16983   arg2 = (Dali::ObjectRegistry *)jarg2;
16984   if (!arg2) {
16985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16986     return 0;
16987   }
16988   {
16989     try {
16990       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
16991     } catch (std::out_of_range& e) {
16992       {
16993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16994       };
16995     } catch (std::exception& e) {
16996       {
16997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16998       };
16999     } catch (...) {
17000       {
17001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17002       };
17003     }
17004   }
17005   jresult = (void *)result;
17006   return jresult;
17007 }
17008
17009
17010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
17011   void * jresult ;
17012   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
17013   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
17014
17015   arg1 = (Dali::ObjectRegistry *)jarg1;
17016   {
17017     try {
17018       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
17019     } catch (std::out_of_range& e) {
17020       {
17021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17022       };
17023     } catch (std::exception& e) {
17024       {
17025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17026       };
17027     } catch (...) {
17028       {
17029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17030       };
17031     }
17032   }
17033   jresult = (void *)result;
17034   return jresult;
17035 }
17036
17037
17038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
17039   void * jresult ;
17040   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
17041   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
17042
17043   arg1 = (Dali::ObjectRegistry *)jarg1;
17044   {
17045     try {
17046       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
17047     } catch (std::out_of_range& e) {
17048       {
17049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17050       };
17051     } catch (std::exception& e) {
17052       {
17053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17054       };
17055     } catch (...) {
17056       {
17057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17058       };
17059     }
17060   }
17061   jresult = (void *)result;
17062   return jresult;
17063 }
17064
17065
17066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
17067   void * jresult ;
17068   Dali::PropertyCondition *result = 0 ;
17069
17070   {
17071     try {
17072       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
17073     } catch (std::out_of_range& e) {
17074       {
17075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17076       };
17077     } catch (std::exception& e) {
17078       {
17079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17080       };
17081     } catch (...) {
17082       {
17083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17084       };
17085     }
17086   }
17087   jresult = (void *)result;
17088   return jresult;
17089 }
17090
17091
17092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
17093   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17094
17095   arg1 = (Dali::PropertyCondition *)jarg1;
17096   {
17097     try {
17098       delete arg1;
17099     } catch (std::out_of_range& e) {
17100       {
17101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17102       };
17103     } catch (std::exception& e) {
17104       {
17105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17106       };
17107     } catch (...) {
17108       {
17109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17110       };
17111     }
17112   }
17113 }
17114
17115
17116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
17117   void * jresult ;
17118   Dali::PropertyCondition *arg1 = 0 ;
17119   Dali::PropertyCondition *result = 0 ;
17120
17121   arg1 = (Dali::PropertyCondition *)jarg1;
17122   if (!arg1) {
17123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17124     return 0;
17125   }
17126   {
17127     try {
17128       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
17129     } catch (std::out_of_range& e) {
17130       {
17131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17132       };
17133     } catch (std::exception& e) {
17134       {
17135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17136       };
17137     } catch (...) {
17138       {
17139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17140       };
17141     }
17142   }
17143   jresult = (void *)result;
17144   return jresult;
17145 }
17146
17147
17148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
17149   void * jresult ;
17150   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17151   Dali::PropertyCondition *arg2 = 0 ;
17152   Dali::PropertyCondition *result = 0 ;
17153
17154   arg1 = (Dali::PropertyCondition *)jarg1;
17155   arg2 = (Dali::PropertyCondition *)jarg2;
17156   if (!arg2) {
17157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17158     return 0;
17159   }
17160   {
17161     try {
17162       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
17163     } catch (std::out_of_range& e) {
17164       {
17165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17166       };
17167     } catch (std::exception& e) {
17168       {
17169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17170       };
17171     } catch (...) {
17172       {
17173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17174       };
17175     }
17176   }
17177   jresult = (void *)result;
17178   return jresult;
17179 }
17180
17181
17182 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
17183   unsigned long jresult ;
17184   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17185   std::size_t result;
17186
17187   arg1 = (Dali::PropertyCondition *)jarg1;
17188   {
17189     try {
17190       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
17191     } catch (std::out_of_range& e) {
17192       {
17193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17194       };
17195     } catch (std::exception& e) {
17196       {
17197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17198       };
17199     } catch (...) {
17200       {
17201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17202       };
17203     }
17204   }
17205   jresult = (unsigned long)result;
17206   return jresult;
17207 }
17208
17209
17210 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
17211   float jresult ;
17212   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17213   std::size_t arg2 ;
17214   float result;
17215
17216   arg1 = (Dali::PropertyCondition *)jarg1;
17217   arg2 = (std::size_t)jarg2;
17218   {
17219     try {
17220       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
17221     } catch (std::out_of_range& e) {
17222       {
17223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17224       };
17225     } catch (std::exception& e) {
17226       {
17227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17228       };
17229     } catch (...) {
17230       {
17231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17232       };
17233     }
17234   }
17235   jresult = result;
17236   return jresult;
17237 }
17238
17239
17240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
17241   void * jresult ;
17242   float arg1 ;
17243   Dali::PropertyCondition result;
17244
17245   arg1 = (float)jarg1;
17246   {
17247     try {
17248       result = Dali::LessThanCondition(arg1);
17249     } catch (std::out_of_range& e) {
17250       {
17251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17252       };
17253     } catch (std::exception& e) {
17254       {
17255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17256       };
17257     } catch (...) {
17258       {
17259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17260       };
17261     }
17262   }
17263   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17264   return jresult;
17265 }
17266
17267
17268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
17269   void * jresult ;
17270   float arg1 ;
17271   Dali::PropertyCondition result;
17272
17273   arg1 = (float)jarg1;
17274   {
17275     try {
17276       result = Dali::GreaterThanCondition(arg1);
17277     } catch (std::out_of_range& e) {
17278       {
17279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17280       };
17281     } catch (std::exception& e) {
17282       {
17283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17284       };
17285     } catch (...) {
17286       {
17287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17288       };
17289     }
17290   }
17291   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17292   return jresult;
17293 }
17294
17295
17296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
17297   void * jresult ;
17298   float arg1 ;
17299   float arg2 ;
17300   Dali::PropertyCondition result;
17301
17302   arg1 = (float)jarg1;
17303   arg2 = (float)jarg2;
17304   {
17305     try {
17306       result = Dali::InsideCondition(arg1,arg2);
17307     } catch (std::out_of_range& e) {
17308       {
17309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17310       };
17311     } catch (std::exception& e) {
17312       {
17313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17314       };
17315     } catch (...) {
17316       {
17317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17318       };
17319     }
17320   }
17321   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17322   return jresult;
17323 }
17324
17325
17326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
17327   void * jresult ;
17328   float arg1 ;
17329   float arg2 ;
17330   Dali::PropertyCondition result;
17331
17332   arg1 = (float)jarg1;
17333   arg2 = (float)jarg2;
17334   {
17335     try {
17336       result = Dali::OutsideCondition(arg1,arg2);
17337     } catch (std::out_of_range& e) {
17338       {
17339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17340       };
17341     } catch (std::exception& e) {
17342       {
17343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17344       };
17345     } catch (...) {
17346       {
17347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17348       };
17349     }
17350   }
17351   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17352   return jresult;
17353 }
17354
17355
17356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
17357   void * jresult ;
17358   float arg1 ;
17359   float arg2 ;
17360   Dali::PropertyCondition result;
17361
17362   arg1 = (float)jarg1;
17363   arg2 = (float)jarg2;
17364   {
17365     try {
17366       result = Dali::StepCondition(arg1,arg2);
17367     } catch (std::out_of_range& e) {
17368       {
17369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17370       };
17371     } catch (std::exception& e) {
17372       {
17373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17374       };
17375     } catch (...) {
17376       {
17377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17378       };
17379     }
17380   }
17381   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17382   return jresult;
17383 }
17384
17385
17386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
17387   void * jresult ;
17388   float arg1 ;
17389   Dali::PropertyCondition result;
17390
17391   arg1 = (float)jarg1;
17392   {
17393     try {
17394       result = Dali::StepCondition(arg1);
17395     } catch (std::out_of_range& e) {
17396       {
17397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17398       };
17399     } catch (std::exception& e) {
17400       {
17401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17402       };
17403     } catch (...) {
17404       {
17405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17406       };
17407     }
17408   }
17409   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17410   return jresult;
17411 }
17412
17413
17414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
17415   void * jresult ;
17416   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
17417   Dali::PropertyCondition result;
17418
17419   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
17420   if (!arg1) {
17421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
17422     return 0;
17423   }
17424   {
17425     try {
17426       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
17427     } catch (std::out_of_range& e) {
17428       {
17429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17430       };
17431     } catch (std::exception& e) {
17432       {
17433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17434       };
17435     } catch (...) {
17436       {
17437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17438       };
17439     }
17440   }
17441   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17442   return jresult;
17443 }
17444
17445
17446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
17447   void * jresult ;
17448   Dali::PropertyNotification *result = 0 ;
17449
17450   {
17451     try {
17452       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
17453     } catch (std::out_of_range& e) {
17454       {
17455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17456       };
17457     } catch (std::exception& e) {
17458       {
17459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17460       };
17461     } catch (...) {
17462       {
17463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17464       };
17465     }
17466   }
17467   jresult = (void *)result;
17468   return jresult;
17469 }
17470
17471
17472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
17473   void * jresult ;
17474   Dali::BaseHandle arg1 ;
17475   Dali::BaseHandle *argp1 ;
17476   Dali::PropertyNotification result;
17477
17478   argp1 = (Dali::BaseHandle *)jarg1;
17479   if (!argp1) {
17480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17481     return 0;
17482   }
17483   arg1 = *argp1;
17484   {
17485     try {
17486       result = Dali::PropertyNotification::DownCast(arg1);
17487     } catch (std::out_of_range& e) {
17488       {
17489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17490       };
17491     } catch (std::exception& e) {
17492       {
17493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17494       };
17495     } catch (...) {
17496       {
17497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17498       };
17499     }
17500   }
17501   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
17502   return jresult;
17503 }
17504
17505
17506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
17507   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17508
17509   arg1 = (Dali::PropertyNotification *)jarg1;
17510   {
17511     try {
17512       delete arg1;
17513     } catch (std::out_of_range& e) {
17514       {
17515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17516       };
17517     } catch (std::exception& e) {
17518       {
17519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17520       };
17521     } catch (...) {
17522       {
17523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17524       };
17525     }
17526   }
17527 }
17528
17529
17530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
17531   void * jresult ;
17532   Dali::PropertyNotification *arg1 = 0 ;
17533   Dali::PropertyNotification *result = 0 ;
17534
17535   arg1 = (Dali::PropertyNotification *)jarg1;
17536   if (!arg1) {
17537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17538     return 0;
17539   }
17540   {
17541     try {
17542       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
17543     } catch (std::out_of_range& e) {
17544       {
17545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17546       };
17547     } catch (std::exception& e) {
17548       {
17549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17550       };
17551     } catch (...) {
17552       {
17553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17554       };
17555     }
17556   }
17557   jresult = (void *)result;
17558   return jresult;
17559 }
17560
17561
17562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
17563   void * jresult ;
17564   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17565   Dali::PropertyNotification *arg2 = 0 ;
17566   Dali::PropertyNotification *result = 0 ;
17567
17568   arg1 = (Dali::PropertyNotification *)jarg1;
17569   arg2 = (Dali::PropertyNotification *)jarg2;
17570   if (!arg2) {
17571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17572     return 0;
17573   }
17574   {
17575     try {
17576       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
17577     } catch (std::out_of_range& e) {
17578       {
17579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17580       };
17581     } catch (std::exception& e) {
17582       {
17583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17584       };
17585     } catch (...) {
17586       {
17587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17588       };
17589     }
17590   }
17591   jresult = (void *)result;
17592   return jresult;
17593 }
17594
17595
17596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
17597   void * jresult ;
17598   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17599   Dali::PropertyCondition result;
17600
17601   arg1 = (Dali::PropertyNotification *)jarg1;
17602   {
17603     try {
17604       result = (arg1)->GetCondition();
17605     } catch (std::out_of_range& e) {
17606       {
17607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17608       };
17609     } catch (std::exception& e) {
17610       {
17611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17612       };
17613     } catch (...) {
17614       {
17615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17616       };
17617     }
17618   }
17619   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17620   return jresult;
17621 }
17622
17623
17624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
17625   void * jresult ;
17626   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17627   Dali::Handle result;
17628
17629   arg1 = (Dali::PropertyNotification *)jarg1;
17630   {
17631     try {
17632       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
17633     } catch (std::out_of_range& e) {
17634       {
17635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17636       };
17637     } catch (std::exception& e) {
17638       {
17639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17640       };
17641     } catch (...) {
17642       {
17643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17644       };
17645     }
17646   }
17647   jresult = new Dali::Handle((const Dali::Handle &)result);
17648   return jresult;
17649 }
17650
17651
17652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
17653   int jresult ;
17654   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17655   Dali::Property::Index result;
17656
17657   arg1 = (Dali::PropertyNotification *)jarg1;
17658   {
17659     try {
17660       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
17661     } catch (std::out_of_range& e) {
17662       {
17663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17664       };
17665     } catch (std::exception& e) {
17666       {
17667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17668       };
17669     } catch (...) {
17670       {
17671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17672       };
17673     }
17674   }
17675   jresult = result;
17676   return jresult;
17677 }
17678
17679
17680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
17681   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17682   Dali::PropertyNotification::NotifyMode arg2 ;
17683
17684   arg1 = (Dali::PropertyNotification *)jarg1;
17685   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
17686   {
17687     try {
17688       (arg1)->SetNotifyMode(arg2);
17689     } catch (std::out_of_range& e) {
17690       {
17691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17692       };
17693     } catch (std::exception& e) {
17694       {
17695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17696       };
17697     } catch (...) {
17698       {
17699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17700       };
17701     }
17702   }
17703 }
17704
17705
17706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
17707   int jresult ;
17708   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17709   Dali::PropertyNotification::NotifyMode result;
17710
17711   arg1 = (Dali::PropertyNotification *)jarg1;
17712   {
17713     try {
17714       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
17715     } catch (std::out_of_range& e) {
17716       {
17717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17718       };
17719     } catch (std::exception& e) {
17720       {
17721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17722       };
17723     } catch (...) {
17724       {
17725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17726       };
17727     }
17728   }
17729   jresult = (int)result;
17730   return jresult;
17731 }
17732
17733
17734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
17735   unsigned int jresult ;
17736   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17737   bool result;
17738
17739   arg1 = (Dali::PropertyNotification *)jarg1;
17740   {
17741     try {
17742       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
17743     } catch (std::out_of_range& e) {
17744       {
17745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17746       };
17747     } catch (std::exception& e) {
17748       {
17749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17750       };
17751     } catch (...) {
17752       {
17753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17754       };
17755     }
17756   }
17757   jresult = result;
17758   return jresult;
17759 }
17760
17761
17762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
17763   void * jresult ;
17764   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17765   Dali::PropertyNotifySignalType *result = 0 ;
17766
17767   arg1 = (Dali::PropertyNotification *)jarg1;
17768   {
17769     try {
17770       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
17771     } catch (std::out_of_range& e) {
17772       {
17773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17774       };
17775     } catch (std::exception& e) {
17776       {
17777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17778       };
17779     } catch (...) {
17780       {
17781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17782       };
17783     }
17784   }
17785   jresult = (void *)result;
17786   return jresult;
17787 }
17788
17789
17790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
17791   void * jresult ;
17792   Dali::Handle *result = 0 ;
17793
17794   {
17795     try {
17796       result = (Dali::Handle *)new Dali::Handle();
17797     } catch (std::out_of_range& e) {
17798       {
17799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17800       };
17801     } catch (std::exception& e) {
17802       {
17803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17804       };
17805     } catch (...) {
17806       {
17807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17808       };
17809     }
17810   }
17811   jresult = (void *)result;
17812   return jresult;
17813 }
17814
17815
17816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
17817   void * jresult ;
17818   Dali::Handle result;
17819
17820   {
17821     try {
17822       result = Dali::Handle::New();
17823     } catch (std::out_of_range& e) {
17824       {
17825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17826       };
17827     } catch (std::exception& e) {
17828       {
17829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17830       };
17831     } catch (...) {
17832       {
17833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17834       };
17835     }
17836   }
17837   jresult = new Dali::Handle((const Dali::Handle &)result);
17838   return jresult;
17839 }
17840
17841
17842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
17843   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17844
17845   arg1 = (Dali::Handle *)jarg1;
17846   {
17847     try {
17848       delete arg1;
17849     } catch (std::out_of_range& e) {
17850       {
17851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17852       };
17853     } catch (std::exception& e) {
17854       {
17855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17856       };
17857     } catch (...) {
17858       {
17859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17860       };
17861     }
17862   }
17863 }
17864
17865
17866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
17867   void * jresult ;
17868   Dali::Handle *arg1 = 0 ;
17869   Dali::Handle *result = 0 ;
17870
17871   arg1 = (Dali::Handle *)jarg1;
17872   if (!arg1) {
17873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17874     return 0;
17875   }
17876   {
17877     try {
17878       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
17879     } catch (std::out_of_range& e) {
17880       {
17881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17882       };
17883     } catch (std::exception& e) {
17884       {
17885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17886       };
17887     } catch (...) {
17888       {
17889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17890       };
17891     }
17892   }
17893   jresult = (void *)result;
17894   return jresult;
17895 }
17896
17897
17898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
17899   void * jresult ;
17900   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17901   Dali::Handle *arg2 = 0 ;
17902   Dali::Handle *result = 0 ;
17903
17904   arg1 = (Dali::Handle *)jarg1;
17905   arg2 = (Dali::Handle *)jarg2;
17906   if (!arg2) {
17907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17908     return 0;
17909   }
17910   {
17911     try {
17912       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
17913     } catch (std::out_of_range& e) {
17914       {
17915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17916       };
17917     } catch (std::exception& e) {
17918       {
17919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17920       };
17921     } catch (...) {
17922       {
17923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17924       };
17925     }
17926   }
17927   jresult = (void *)result;
17928   return jresult;
17929 }
17930
17931
17932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
17933   void * jresult ;
17934   Dali::BaseHandle arg1 ;
17935   Dali::BaseHandle *argp1 ;
17936   Dali::Handle result;
17937
17938   argp1 = (Dali::BaseHandle *)jarg1;
17939   if (!argp1) {
17940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17941     return 0;
17942   }
17943   arg1 = *argp1;
17944   {
17945     try {
17946       result = Dali::Handle::DownCast(arg1);
17947     } catch (std::out_of_range& e) {
17948       {
17949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17950       };
17951     } catch (std::exception& e) {
17952       {
17953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17954       };
17955     } catch (...) {
17956       {
17957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17958       };
17959     }
17960   }
17961   jresult = new Dali::Handle((const Dali::Handle &)result);
17962   return jresult;
17963 }
17964
17965
17966 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
17967   unsigned int jresult ;
17968   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17969   Dali::Handle::Capability arg2 ;
17970   bool result;
17971
17972   arg1 = (Dali::Handle *)jarg1;
17973   arg2 = (Dali::Handle::Capability)jarg2;
17974   {
17975     try {
17976       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
17977     } catch (std::out_of_range& e) {
17978       {
17979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17980       };
17981     } catch (std::exception& e) {
17982       {
17983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17984       };
17985     } catch (...) {
17986       {
17987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17988       };
17989     }
17990   }
17991   jresult = result;
17992   return jresult;
17993 }
17994
17995
17996 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
17997   unsigned int jresult ;
17998   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17999   unsigned int result;
18000
18001   arg1 = (Dali::Handle *)jarg1;
18002   {
18003     try {
18004       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
18005     } catch (std::out_of_range& e) {
18006       {
18007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18008       };
18009     } catch (std::exception& e) {
18010       {
18011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18012       };
18013     } catch (...) {
18014       {
18015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18016       };
18017     }
18018   }
18019   jresult = result;
18020   return jresult;
18021 }
18022
18023
18024 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
18025   char * jresult ;
18026   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18027   Dali::Property::Index arg2 ;
18028   std::string result;
18029
18030   arg1 = (Dali::Handle *)jarg1;
18031   arg2 = (Dali::Property::Index)jarg2;
18032   {
18033     try {
18034       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
18035     } catch (std::out_of_range& e) {
18036       {
18037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18038       };
18039     } catch (std::exception& e) {
18040       {
18041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18042       };
18043     } catch (...) {
18044       {
18045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18046       };
18047     }
18048   }
18049   jresult = SWIG_csharp_string_callback((&result)->c_str());
18050   return jresult;
18051 }
18052
18053
18054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
18055   int jresult ;
18056   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18057   std::string *arg2 = 0 ;
18058   Dali::Property::Index result;
18059
18060   arg1 = (Dali::Handle *)jarg1;
18061   if (!jarg2) {
18062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18063     return 0;
18064   }
18065   std::string arg2_str(jarg2);
18066   arg2 = &arg2_str;
18067   {
18068     try {
18069       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
18070     } catch (std::out_of_range& e) {
18071       {
18072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18073       };
18074     } catch (std::exception& e) {
18075       {
18076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18077       };
18078     } catch (...) {
18079       {
18080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18081       };
18082     }
18083   }
18084   jresult = result;
18085
18086   //argout typemap for const std::string&
18087
18088   return jresult;
18089 }
18090
18091
18092 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
18093   unsigned int jresult ;
18094   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18095   Dali::Property::Index arg2 ;
18096   bool result;
18097
18098   arg1 = (Dali::Handle *)jarg1;
18099   arg2 = (Dali::Property::Index)jarg2;
18100   {
18101     try {
18102       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
18103     } catch (std::out_of_range& e) {
18104       {
18105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18106       };
18107     } catch (std::exception& e) {
18108       {
18109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18110       };
18111     } catch (...) {
18112       {
18113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18114       };
18115     }
18116   }
18117   jresult = result;
18118   return jresult;
18119 }
18120
18121
18122 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
18123   unsigned int jresult ;
18124   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18125   Dali::Property::Index arg2 ;
18126   bool result;
18127
18128   arg1 = (Dali::Handle *)jarg1;
18129   arg2 = (Dali::Property::Index)jarg2;
18130   {
18131     try {
18132       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
18133     } catch (std::out_of_range& e) {
18134       {
18135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18136       };
18137     } catch (std::exception& e) {
18138       {
18139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18140       };
18141     } catch (...) {
18142       {
18143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18144       };
18145     }
18146   }
18147   jresult = result;
18148   return jresult;
18149 }
18150
18151
18152 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
18153   unsigned int jresult ;
18154   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18155   Dali::Property::Index arg2 ;
18156   bool result;
18157
18158   arg1 = (Dali::Handle *)jarg1;
18159   arg2 = (Dali::Property::Index)jarg2;
18160   {
18161     try {
18162       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
18163     } catch (std::out_of_range& e) {
18164       {
18165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18166       };
18167     } catch (std::exception& e) {
18168       {
18169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18170       };
18171     } catch (...) {
18172       {
18173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18174       };
18175     }
18176   }
18177   jresult = result;
18178   return jresult;
18179 }
18180
18181
18182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
18183   int jresult ;
18184   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18185   Dali::Property::Index arg2 ;
18186   Dali::Property::Type result;
18187
18188   arg1 = (Dali::Handle *)jarg1;
18189   arg2 = (Dali::Property::Index)jarg2;
18190   {
18191     try {
18192       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
18193     } catch (std::out_of_range& e) {
18194       {
18195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18196       };
18197     } catch (std::exception& e) {
18198       {
18199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18200       };
18201     } catch (...) {
18202       {
18203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18204       };
18205     }
18206   }
18207   jresult = (int)result;
18208   return jresult;
18209 }
18210
18211
18212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
18213   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18214   Dali::Property::Index arg2 ;
18215   Dali::Property::Value *arg3 = 0 ;
18216
18217   arg1 = (Dali::Handle *)jarg1;
18218   arg2 = (Dali::Property::Index)jarg2;
18219   arg3 = (Dali::Property::Value *)jarg3;
18220   if (!arg3) {
18221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18222     return ;
18223   }
18224   {
18225     try {
18226       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
18227     } catch (std::out_of_range& e) {
18228       {
18229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18230       };
18231     } catch (std::exception& e) {
18232       {
18233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18234       };
18235     } catch (...) {
18236       {
18237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18238       };
18239     }
18240   }
18241 }
18242
18243
18244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
18245   int jresult ;
18246   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18247   std::string *arg2 = 0 ;
18248   Dali::Property::Value *arg3 = 0 ;
18249   Dali::Property::Index result;
18250
18251   arg1 = (Dali::Handle *)jarg1;
18252   if (!jarg2) {
18253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18254     return 0;
18255   }
18256   std::string arg2_str(jarg2);
18257   arg2 = &arg2_str;
18258   arg3 = (Dali::Property::Value *)jarg3;
18259   if (!arg3) {
18260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18261     return 0;
18262   }
18263   {
18264     try {
18265       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
18266     } catch (std::out_of_range& e) {
18267       {
18268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18269       };
18270     } catch (std::exception& e) {
18271       {
18272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18273       };
18274     } catch (...) {
18275       {
18276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18277       };
18278     }
18279   }
18280   jresult = result;
18281
18282   //argout typemap for const std::string&
18283
18284   return jresult;
18285 }
18286
18287
18288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
18289   int jresult ;
18290   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18291   std::string *arg2 = 0 ;
18292   Dali::Property::Value *arg3 = 0 ;
18293   Dali::Property::AccessMode arg4 ;
18294   Dali::Property::Index result;
18295
18296   arg1 = (Dali::Handle *)jarg1;
18297   if (!jarg2) {
18298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18299     return 0;
18300   }
18301   std::string arg2_str(jarg2);
18302   arg2 = &arg2_str;
18303   arg3 = (Dali::Property::Value *)jarg3;
18304   if (!arg3) {
18305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18306     return 0;
18307   }
18308   arg4 = (Dali::Property::AccessMode)jarg4;
18309   {
18310     try {
18311       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
18312     } catch (std::out_of_range& e) {
18313       {
18314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18315       };
18316     } catch (std::exception& e) {
18317       {
18318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18319       };
18320     } catch (...) {
18321       {
18322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18323       };
18324     }
18325   }
18326   jresult = result;
18327
18328   //argout typemap for const std::string&
18329
18330   return jresult;
18331 }
18332
18333
18334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
18335   void * jresult ;
18336   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18337   Dali::Property::Index arg2 ;
18338   Dali::Property::Value result;
18339
18340   arg1 = (Dali::Handle *)jarg1;
18341   arg2 = (Dali::Property::Index)jarg2;
18342   {
18343     try {
18344       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
18345     } catch (std::out_of_range& e) {
18346       {
18347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18348       };
18349     } catch (std::exception& e) {
18350       {
18351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18352       };
18353     } catch (...) {
18354       {
18355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18356       };
18357     }
18358   }
18359   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
18360   return jresult;
18361 }
18362
18363
18364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
18365   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18366   Dali::Property::IndexContainer *arg2 = 0 ;
18367
18368   arg1 = (Dali::Handle *)jarg1;
18369   arg2 = (Dali::Property::IndexContainer *)jarg2;
18370   if (!arg2) {
18371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18372     return ;
18373   }
18374   {
18375     try {
18376       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
18377     } catch (std::out_of_range& e) {
18378       {
18379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18380       };
18381     } catch (std::exception& e) {
18382       {
18383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18384       };
18385     } catch (...) {
18386       {
18387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18388       };
18389     }
18390   }
18391 }
18392
18393
18394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
18395   void * jresult ;
18396   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18397   Dali::Property::Index arg2 ;
18398   Dali::PropertyCondition *arg3 = 0 ;
18399   Dali::PropertyNotification result;
18400
18401   arg1 = (Dali::Handle *)jarg1;
18402   arg2 = (Dali::Property::Index)jarg2;
18403   arg3 = (Dali::PropertyCondition *)jarg3;
18404   if (!arg3) {
18405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18406     return 0;
18407   }
18408   {
18409     try {
18410       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
18411     } catch (std::out_of_range& e) {
18412       {
18413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18414       };
18415     } catch (std::exception& e) {
18416       {
18417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18418       };
18419     } catch (...) {
18420       {
18421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18422       };
18423     }
18424   }
18425   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18426   return jresult;
18427 }
18428
18429
18430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
18431   void * jresult ;
18432   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18433   Dali::Property::Index arg2 ;
18434   int arg3 ;
18435   Dali::PropertyCondition *arg4 = 0 ;
18436   Dali::PropertyNotification result;
18437
18438   arg1 = (Dali::Handle *)jarg1;
18439   arg2 = (Dali::Property::Index)jarg2;
18440   arg3 = (int)jarg3;
18441   arg4 = (Dali::PropertyCondition *)jarg4;
18442   if (!arg4) {
18443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18444     return 0;
18445   }
18446   {
18447     try {
18448       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
18449     } catch (std::out_of_range& e) {
18450       {
18451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18452       };
18453     } catch (std::exception& e) {
18454       {
18455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18456       };
18457     } catch (...) {
18458       {
18459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18460       };
18461     }
18462   }
18463   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18464   return jresult;
18465 }
18466
18467
18468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
18469   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18470   Dali::PropertyNotification arg2 ;
18471   Dali::PropertyNotification *argp2 ;
18472
18473   arg1 = (Dali::Handle *)jarg1;
18474   argp2 = (Dali::PropertyNotification *)jarg2;
18475   if (!argp2) {
18476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
18477     return ;
18478   }
18479   arg2 = *argp2;
18480   {
18481     try {
18482       (arg1)->RemovePropertyNotification(arg2);
18483     } catch (std::out_of_range& e) {
18484       {
18485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18486       };
18487     } catch (std::exception& e) {
18488       {
18489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18490       };
18491     } catch (...) {
18492       {
18493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18494       };
18495     }
18496   }
18497 }
18498
18499
18500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
18501   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18502
18503   arg1 = (Dali::Handle *)jarg1;
18504   {
18505     try {
18506       (arg1)->RemovePropertyNotifications();
18507     } catch (std::out_of_range& e) {
18508       {
18509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18510       };
18511     } catch (std::exception& e) {
18512       {
18513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18514       };
18515     } catch (...) {
18516       {
18517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18518       };
18519     }
18520   }
18521 }
18522
18523
18524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
18525   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18526
18527   arg1 = (Dali::Handle *)jarg1;
18528   {
18529     try {
18530       (arg1)->RemoveConstraints();
18531     } catch (std::out_of_range& e) {
18532       {
18533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18534       };
18535     } catch (std::exception& e) {
18536       {
18537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18538       };
18539     } catch (...) {
18540       {
18541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18542       };
18543     }
18544   }
18545 }
18546
18547
18548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
18549   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18550   unsigned int arg2 ;
18551
18552   arg1 = (Dali::Handle *)jarg1;
18553   arg2 = (unsigned int)jarg2;
18554   {
18555     try {
18556       (arg1)->RemoveConstraints(arg2);
18557     } catch (std::out_of_range& e) {
18558       {
18559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18560       };
18561     } catch (std::exception& e) {
18562       {
18563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18564       };
18565     } catch (...) {
18566       {
18567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18568       };
18569     }
18570   }
18571 }
18572
18573
18574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
18575   int jresult ;
18576   Dali::Property::Index result;
18577
18578   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
18579   jresult = result;
18580   return jresult;
18581 }
18582
18583
18584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
18585   void * jresult ;
18586   Dali::Handle result;
18587
18588   {
18589     try {
18590       result = Dali::WeightObject::New();
18591     } catch (std::out_of_range& e) {
18592       {
18593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18594       };
18595     } catch (std::exception& e) {
18596       {
18597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18598       };
18599     } catch (...) {
18600       {
18601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18602       };
18603     }
18604   }
18605   jresult = new Dali::Handle((const Dali::Handle &)result);
18606   return jresult;
18607 }
18608
18609
18610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
18611   void * jresult ;
18612   Dali::TypeInfo *result = 0 ;
18613
18614   {
18615     try {
18616       result = (Dali::TypeInfo *)new Dali::TypeInfo();
18617     } catch (std::out_of_range& e) {
18618       {
18619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18620       };
18621     } catch (std::exception& e) {
18622       {
18623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18624       };
18625     } catch (...) {
18626       {
18627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18628       };
18629     }
18630   }
18631   jresult = (void *)result;
18632   return jresult;
18633 }
18634
18635
18636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
18637   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18638
18639   arg1 = (Dali::TypeInfo *)jarg1;
18640   {
18641     try {
18642       delete arg1;
18643     } catch (std::out_of_range& e) {
18644       {
18645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18646       };
18647     } catch (std::exception& e) {
18648       {
18649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18650       };
18651     } catch (...) {
18652       {
18653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18654       };
18655     }
18656   }
18657 }
18658
18659
18660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
18661   void * jresult ;
18662   Dali::TypeInfo *arg1 = 0 ;
18663   Dali::TypeInfo *result = 0 ;
18664
18665   arg1 = (Dali::TypeInfo *)jarg1;
18666   if (!arg1) {
18667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18668     return 0;
18669   }
18670   {
18671     try {
18672       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
18673     } catch (std::out_of_range& e) {
18674       {
18675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18676       };
18677     } catch (std::exception& e) {
18678       {
18679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18680       };
18681     } catch (...) {
18682       {
18683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18684       };
18685     }
18686   }
18687   jresult = (void *)result;
18688   return jresult;
18689 }
18690
18691
18692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
18693   void * jresult ;
18694   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18695   Dali::TypeInfo *arg2 = 0 ;
18696   Dali::TypeInfo *result = 0 ;
18697
18698   arg1 = (Dali::TypeInfo *)jarg1;
18699   arg2 = (Dali::TypeInfo *)jarg2;
18700   if (!arg2) {
18701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18702     return 0;
18703   }
18704   {
18705     try {
18706       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
18707     } catch (std::out_of_range& e) {
18708       {
18709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18710       };
18711     } catch (std::exception& e) {
18712       {
18713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18714       };
18715     } catch (...) {
18716       {
18717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18718       };
18719     }
18720   }
18721   jresult = (void *)result;
18722   return jresult;
18723 }
18724
18725
18726 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
18727   char * jresult ;
18728   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18729   std::string *result = 0 ;
18730
18731   arg1 = (Dali::TypeInfo *)jarg1;
18732   {
18733     try {
18734       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
18735     } catch (std::out_of_range& e) {
18736       {
18737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18738       };
18739     } catch (std::exception& e) {
18740       {
18741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18742       };
18743     } catch (...) {
18744       {
18745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18746       };
18747     }
18748   }
18749   jresult = SWIG_csharp_string_callback(result->c_str());
18750   return jresult;
18751 }
18752
18753
18754 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
18755   char * jresult ;
18756   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18757   std::string *result = 0 ;
18758
18759   arg1 = (Dali::TypeInfo *)jarg1;
18760   {
18761     try {
18762       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
18763     } catch (std::out_of_range& e) {
18764       {
18765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18766       };
18767     } catch (std::exception& e) {
18768       {
18769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18770       };
18771     } catch (...) {
18772       {
18773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18774       };
18775     }
18776   }
18777   jresult = SWIG_csharp_string_callback(result->c_str());
18778   return jresult;
18779 }
18780
18781
18782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
18783   void * jresult ;
18784   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18785   Dali::BaseHandle result;
18786
18787   arg1 = (Dali::TypeInfo *)jarg1;
18788   {
18789     try {
18790       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
18791     } catch (std::out_of_range& e) {
18792       {
18793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18794       };
18795     } catch (std::exception& e) {
18796       {
18797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18798       };
18799     } catch (...) {
18800       {
18801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18802       };
18803     }
18804   }
18805   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
18806   return jresult;
18807 }
18808
18809
18810 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
18811   unsigned long jresult ;
18812   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18813   size_t result;
18814
18815   arg1 = (Dali::TypeInfo *)jarg1;
18816   {
18817     try {
18818       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
18819     } catch (std::out_of_range& e) {
18820       {
18821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18822       };
18823     } catch (std::exception& e) {
18824       {
18825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18826       };
18827     } catch (...) {
18828       {
18829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18830       };
18831     }
18832   }
18833   jresult = (unsigned long)result;
18834   return jresult;
18835 }
18836
18837
18838 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
18839   char * jresult ;
18840   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18841   size_t arg2 ;
18842   std::string result;
18843
18844   arg1 = (Dali::TypeInfo *)jarg1;
18845   arg2 = (size_t)jarg2;
18846   {
18847     try {
18848       result = (arg1)->GetActionName(arg2);
18849     } catch (std::out_of_range& e) {
18850       {
18851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18852       };
18853     } catch (std::exception& e) {
18854       {
18855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18856       };
18857     } catch (...) {
18858       {
18859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18860       };
18861     }
18862   }
18863   jresult = SWIG_csharp_string_callback((&result)->c_str());
18864   return jresult;
18865 }
18866
18867
18868 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
18869   unsigned long jresult ;
18870   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18871   size_t result;
18872
18873   arg1 = (Dali::TypeInfo *)jarg1;
18874   {
18875     try {
18876       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
18877     } catch (std::out_of_range& e) {
18878       {
18879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18880       };
18881     } catch (std::exception& e) {
18882       {
18883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18884       };
18885     } catch (...) {
18886       {
18887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18888       };
18889     }
18890   }
18891   jresult = (unsigned long)result;
18892   return jresult;
18893 }
18894
18895
18896 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
18897   char * jresult ;
18898   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18899   size_t arg2 ;
18900   std::string result;
18901
18902   arg1 = (Dali::TypeInfo *)jarg1;
18903   arg2 = (size_t)jarg2;
18904   {
18905     try {
18906       result = (arg1)->GetSignalName(arg2);
18907     } catch (std::out_of_range& e) {
18908       {
18909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18910       };
18911     } catch (std::exception& e) {
18912       {
18913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18914       };
18915     } catch (...) {
18916       {
18917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18918       };
18919     }
18920   }
18921   jresult = SWIG_csharp_string_callback((&result)->c_str());
18922   return jresult;
18923 }
18924
18925
18926 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
18927   unsigned long jresult ;
18928   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18929   size_t result;
18930
18931   arg1 = (Dali::TypeInfo *)jarg1;
18932   {
18933     try {
18934       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
18935     } catch (std::out_of_range& e) {
18936       {
18937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18938       };
18939     } catch (std::exception& e) {
18940       {
18941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18942       };
18943     } catch (...) {
18944       {
18945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18946       };
18947     }
18948   }
18949   jresult = (unsigned long)result;
18950   return jresult;
18951 }
18952
18953
18954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
18955   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18956   Dali::Property::IndexContainer *arg2 = 0 ;
18957
18958   arg1 = (Dali::TypeInfo *)jarg1;
18959   arg2 = (Dali::Property::IndexContainer *)jarg2;
18960   if (!arg2) {
18961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18962     return ;
18963   }
18964   {
18965     try {
18966       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
18967     } catch (std::out_of_range& e) {
18968       {
18969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18970       };
18971     } catch (std::exception& e) {
18972       {
18973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18974       };
18975     } catch (...) {
18976       {
18977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18978       };
18979     }
18980   }
18981 }
18982
18983
18984 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
18985   char * jresult ;
18986   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18987   Dali::Property::Index arg2 ;
18988   std::string *result = 0 ;
18989
18990   arg1 = (Dali::TypeInfo *)jarg1;
18991   arg2 = (Dali::Property::Index)jarg2;
18992   {
18993     try {
18994       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
18995     } catch (std::out_of_range& e) {
18996       {
18997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18998       };
18999     } catch (std::exception& e) {
19000       {
19001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19002       };
19003     } catch (...) {
19004       {
19005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19006       };
19007     }
19008   }
19009   jresult = SWIG_csharp_string_callback(result->c_str());
19010   return jresult;
19011 }
19012
19013
19014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
19015   void * jresult ;
19016   Dali::TypeRegistry result;
19017
19018   {
19019     try {
19020       result = Dali::TypeRegistry::Get();
19021     } catch (std::out_of_range& e) {
19022       {
19023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19024       };
19025     } catch (std::exception& e) {
19026       {
19027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19028       };
19029     } catch (...) {
19030       {
19031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19032       };
19033     }
19034   }
19035   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
19036   return jresult;
19037 }
19038
19039
19040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
19041   void * jresult ;
19042   Dali::TypeRegistry *result = 0 ;
19043
19044   {
19045     try {
19046       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
19047     } catch (std::out_of_range& e) {
19048       {
19049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19050       };
19051     } catch (std::exception& e) {
19052       {
19053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19054       };
19055     } catch (...) {
19056       {
19057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19058       };
19059     }
19060   }
19061   jresult = (void *)result;
19062   return jresult;
19063 }
19064
19065
19066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
19067   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19068
19069   arg1 = (Dali::TypeRegistry *)jarg1;
19070   {
19071     try {
19072       delete arg1;
19073     } catch (std::out_of_range& e) {
19074       {
19075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19076       };
19077     } catch (std::exception& e) {
19078       {
19079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19080       };
19081     } catch (...) {
19082       {
19083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19084       };
19085     }
19086   }
19087 }
19088
19089
19090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
19091   void * jresult ;
19092   Dali::TypeRegistry *arg1 = 0 ;
19093   Dali::TypeRegistry *result = 0 ;
19094
19095   arg1 = (Dali::TypeRegistry *)jarg1;
19096   if (!arg1) {
19097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19098     return 0;
19099   }
19100   {
19101     try {
19102       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
19103     } catch (std::out_of_range& e) {
19104       {
19105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19106       };
19107     } catch (std::exception& e) {
19108       {
19109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19110       };
19111     } catch (...) {
19112       {
19113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19114       };
19115     }
19116   }
19117   jresult = (void *)result;
19118   return jresult;
19119 }
19120
19121
19122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
19123   void * jresult ;
19124   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19125   Dali::TypeRegistry *arg2 = 0 ;
19126   Dali::TypeRegistry *result = 0 ;
19127
19128   arg1 = (Dali::TypeRegistry *)jarg1;
19129   arg2 = (Dali::TypeRegistry *)jarg2;
19130   if (!arg2) {
19131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19132     return 0;
19133   }
19134   {
19135     try {
19136       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
19137     } catch (std::out_of_range& e) {
19138       {
19139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19140       };
19141     } catch (std::exception& e) {
19142       {
19143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19144       };
19145     } catch (...) {
19146       {
19147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19148       };
19149     }
19150   }
19151   jresult = (void *)result;
19152   return jresult;
19153 }
19154
19155
19156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
19157   void * jresult ;
19158   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19159   std::string *arg2 = 0 ;
19160   Dali::TypeInfo result;
19161
19162   arg1 = (Dali::TypeRegistry *)jarg1;
19163   if (!jarg2) {
19164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19165     return 0;
19166   }
19167   std::string arg2_str(jarg2);
19168   arg2 = &arg2_str;
19169   {
19170     try {
19171       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
19172     } catch (std::out_of_range& e) {
19173       {
19174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19175       };
19176     } catch (std::exception& e) {
19177       {
19178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19179       };
19180     } catch (...) {
19181       {
19182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19183       };
19184     }
19185   }
19186   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19187
19188   //argout typemap for const std::string&
19189
19190   return jresult;
19191 }
19192
19193
19194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
19195   void * jresult ;
19196   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19197   std::type_info *arg2 = 0 ;
19198   Dali::TypeInfo result;
19199
19200   arg1 = (Dali::TypeRegistry *)jarg1;
19201   arg2 = (std::type_info *)jarg2;
19202   if (!arg2) {
19203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19204     return 0;
19205   }
19206   {
19207     try {
19208       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
19209     } catch (std::out_of_range& e) {
19210       {
19211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19212       };
19213     } catch (std::exception& e) {
19214       {
19215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19216       };
19217     } catch (...) {
19218       {
19219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19220       };
19221     }
19222   }
19223   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19224   return jresult;
19225 }
19226
19227
19228 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
19229   unsigned long jresult ;
19230   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19231   size_t result;
19232
19233   arg1 = (Dali::TypeRegistry *)jarg1;
19234   {
19235     try {
19236       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
19237     } catch (std::out_of_range& e) {
19238       {
19239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19240       };
19241     } catch (std::exception& e) {
19242       {
19243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19244       };
19245     } catch (...) {
19246       {
19247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19248       };
19249     }
19250   }
19251   jresult = (unsigned long)result;
19252   return jresult;
19253 }
19254
19255
19256 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
19257   char * jresult ;
19258   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19259   size_t arg2 ;
19260   std::string result;
19261
19262   arg1 = (Dali::TypeRegistry *)jarg1;
19263   arg2 = (size_t)jarg2;
19264   {
19265     try {
19266       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
19267     } catch (std::out_of_range& e) {
19268       {
19269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19270       };
19271     } catch (std::exception& e) {
19272       {
19273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19274       };
19275     } catch (...) {
19276       {
19277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19278       };
19279     }
19280   }
19281   jresult = SWIG_csharp_string_callback((&result)->c_str());
19282   return jresult;
19283 }
19284
19285
19286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_2(void * jarg1) {
19287   void * jresult ;
19288   Dali::Internal::TypeRegistry *arg1 = (Dali::Internal::TypeRegistry *) 0 ;
19289   Dali::TypeRegistry *result = 0 ;
19290
19291   arg1 = (Dali::Internal::TypeRegistry *)jarg1;
19292   {
19293     try {
19294       result = (Dali::TypeRegistry *)new Dali::TypeRegistry(arg1);
19295     } catch (std::out_of_range& e) {
19296       {
19297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19298       };
19299     } catch (std::exception& e) {
19300       {
19301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19302       };
19303     } catch (...) {
19304       {
19305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19306       };
19307     }
19308   }
19309   jresult = (void *)result;
19310   return jresult;
19311 }
19312
19313
19314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
19315   void * jresult ;
19316   std::type_info *arg1 = 0 ;
19317   std::type_info *arg2 = 0 ;
19318   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19319   Dali::TypeRegistration *result = 0 ;
19320
19321   arg1 = (std::type_info *)jarg1;
19322   if (!arg1) {
19323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19324     return 0;
19325   }
19326   arg2 = (std::type_info *)jarg2;
19327   if (!arg2) {
19328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19329     return 0;
19330   }
19331   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19332   {
19333     try {
19334       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
19335     } catch (std::out_of_range& e) {
19336       {
19337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19338       };
19339     } catch (std::exception& e) {
19340       {
19341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19342       };
19343     } catch (...) {
19344       {
19345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19346       };
19347     }
19348   }
19349   jresult = (void *)result;
19350   return jresult;
19351 }
19352
19353
19354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
19355   void * jresult ;
19356   std::type_info *arg1 = 0 ;
19357   std::type_info *arg2 = 0 ;
19358   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19359   bool arg4 ;
19360   Dali::TypeRegistration *result = 0 ;
19361
19362   arg1 = (std::type_info *)jarg1;
19363   if (!arg1) {
19364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19365     return 0;
19366   }
19367   arg2 = (std::type_info *)jarg2;
19368   if (!arg2) {
19369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19370     return 0;
19371   }
19372   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19373   arg4 = jarg4 ? true : false;
19374   {
19375     try {
19376       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
19377     } catch (std::out_of_range& e) {
19378       {
19379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19380       };
19381     } catch (std::exception& e) {
19382       {
19383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19384       };
19385     } catch (...) {
19386       {
19387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19388       };
19389     }
19390   }
19391   jresult = (void *)result;
19392   return jresult;
19393 }
19394
19395
19396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
19397   void * jresult ;
19398   std::string *arg1 = 0 ;
19399   std::type_info *arg2 = 0 ;
19400   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19401   Dali::TypeRegistration *result = 0 ;
19402
19403   if (!jarg1) {
19404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19405     return 0;
19406   }
19407   std::string arg1_str(jarg1);
19408   arg1 = &arg1_str;
19409   arg2 = (std::type_info *)jarg2;
19410   if (!arg2) {
19411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19412     return 0;
19413   }
19414   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19415   {
19416     try {
19417       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
19418     } catch (std::out_of_range& e) {
19419       {
19420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19421       };
19422     } catch (std::exception& e) {
19423       {
19424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19425       };
19426     } catch (...) {
19427       {
19428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19429       };
19430     }
19431   }
19432   jresult = (void *)result;
19433
19434   //argout typemap for const std::string&
19435
19436   return jresult;
19437 }
19438
19439
19440 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
19441   char * jresult ;
19442   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19443   std::string result;
19444
19445   arg1 = (Dali::TypeRegistration *)jarg1;
19446   {
19447     try {
19448       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
19449     } catch (std::out_of_range& e) {
19450       {
19451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19452       };
19453     } catch (std::exception& e) {
19454       {
19455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19456       };
19457     } catch (...) {
19458       {
19459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19460       };
19461     }
19462   }
19463   jresult = SWIG_csharp_string_callback((&result)->c_str());
19464   return jresult;
19465 }
19466
19467
19468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
19469   std::string *arg1 = 0 ;
19470   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
19471
19472   if (!jarg1) {
19473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19474     return ;
19475   }
19476   std::string arg1_str(jarg1);
19477   arg1 = &arg1_str;
19478   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
19479   {
19480     try {
19481       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
19482     } catch (std::out_of_range& e) {
19483       {
19484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19485       };
19486     } catch (std::exception& e) {
19487       {
19488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19489       };
19490     } catch (...) {
19491       {
19492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19493       };
19494     }
19495   }
19496
19497   //argout typemap for const std::string&
19498
19499 }
19500
19501
19502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19503   std::string *arg1 = 0 ;
19504   std::string *arg2 = 0 ;
19505   int arg3 ;
19506   Dali::Property::Type arg4 ;
19507   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
19508   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
19509
19510   if (!jarg1) {
19511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19512     return ;
19513   }
19514   std::string arg1_str(jarg1);
19515   arg1 = &arg1_str;
19516   if (!jarg2) {
19517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19518     return ;
19519   }
19520   std::string arg2_str(jarg2);
19521   arg2 = &arg2_str;
19522   arg3 = (int)jarg3;
19523   arg4 = (Dali::Property::Type)jarg4;
19524   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
19525   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
19526   {
19527     try {
19528       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19529     } catch (std::out_of_range& e) {
19530       {
19531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19532       };
19533     } catch (std::exception& e) {
19534       {
19535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19536       };
19537     } catch (...) {
19538       {
19539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19540       };
19541     }
19542   }
19543
19544   //argout typemap for const std::string&
19545
19546
19547   //argout typemap for const std::string&
19548
19549 }
19550
19551
19552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
19553   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19554
19555   arg1 = (Dali::TypeRegistration *)jarg1;
19556   {
19557     try {
19558       delete arg1;
19559     } catch (std::out_of_range& e) {
19560       {
19561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19562       };
19563     } catch (std::exception& e) {
19564       {
19565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19566       };
19567     } catch (...) {
19568       {
19569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19570       };
19571     }
19572   }
19573 }
19574
19575
19576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
19577   void * jresult ;
19578   Dali::TypeRegistration *arg1 = 0 ;
19579   std::string *arg2 = 0 ;
19580   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
19581   Dali::SignalConnectorType *result = 0 ;
19582
19583   arg1 = (Dali::TypeRegistration *)jarg1;
19584   if (!arg1) {
19585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19586     return 0;
19587   }
19588   if (!jarg2) {
19589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19590     return 0;
19591   }
19592   std::string arg2_str(jarg2);
19593   arg2 = &arg2_str;
19594   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
19595   {
19596     try {
19597       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
19598     } catch (std::out_of_range& e) {
19599       {
19600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19601       };
19602     } catch (std::exception& e) {
19603       {
19604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19605       };
19606     } catch (...) {
19607       {
19608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19609       };
19610     }
19611   }
19612   jresult = (void *)result;
19613
19614   //argout typemap for const std::string&
19615
19616   return jresult;
19617 }
19618
19619
19620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
19621   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
19622
19623   arg1 = (Dali::SignalConnectorType *)jarg1;
19624   {
19625     try {
19626       delete arg1;
19627     } catch (std::out_of_range& e) {
19628       {
19629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19630       };
19631     } catch (std::exception& e) {
19632       {
19633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19634       };
19635     } catch (...) {
19636       {
19637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19638       };
19639     }
19640   }
19641 }
19642
19643
19644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
19645   void * jresult ;
19646   Dali::TypeRegistration *arg1 = 0 ;
19647   std::string *arg2 = 0 ;
19648   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
19649   Dali::TypeAction *result = 0 ;
19650
19651   arg1 = (Dali::TypeRegistration *)jarg1;
19652   if (!arg1) {
19653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19654     return 0;
19655   }
19656   if (!jarg2) {
19657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19658     return 0;
19659   }
19660   std::string arg2_str(jarg2);
19661   arg2 = &arg2_str;
19662   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
19663   {
19664     try {
19665       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
19666     } catch (std::out_of_range& e) {
19667       {
19668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19669       };
19670     } catch (std::exception& e) {
19671       {
19672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19673       };
19674     } catch (...) {
19675       {
19676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19677       };
19678     }
19679   }
19680   jresult = (void *)result;
19681
19682   //argout typemap for const std::string&
19683
19684   return jresult;
19685 }
19686
19687
19688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
19689   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
19690
19691   arg1 = (Dali::TypeAction *)jarg1;
19692   {
19693     try {
19694       delete arg1;
19695     } catch (std::out_of_range& e) {
19696       {
19697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19698       };
19699     } catch (std::exception& e) {
19700       {
19701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19702       };
19703     } catch (...) {
19704       {
19705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19706       };
19707     }
19708   }
19709 }
19710
19711
19712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19713   void * jresult ;
19714   Dali::TypeRegistration *arg1 = 0 ;
19715   std::string *arg2 = 0 ;
19716   Dali::Property::Index arg3 ;
19717   Dali::Property::Type arg4 ;
19718   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
19719   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
19720   Dali::PropertyRegistration *result = 0 ;
19721
19722   arg1 = (Dali::TypeRegistration *)jarg1;
19723   if (!arg1) {
19724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19725     return 0;
19726   }
19727   if (!jarg2) {
19728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19729     return 0;
19730   }
19731   std::string arg2_str(jarg2);
19732   arg2 = &arg2_str;
19733   arg3 = (Dali::Property::Index)jarg3;
19734   arg4 = (Dali::Property::Type)jarg4;
19735   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
19736   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
19737   {
19738     try {
19739       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19740     } catch (std::out_of_range& e) {
19741       {
19742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19743       };
19744     } catch (std::exception& e) {
19745       {
19746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19747       };
19748     } catch (...) {
19749       {
19750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19751       };
19752     }
19753   }
19754   jresult = (void *)result;
19755
19756   //argout typemap for const std::string&
19757
19758   return jresult;
19759 }
19760
19761
19762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
19763   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
19764
19765   arg1 = (Dali::PropertyRegistration *)jarg1;
19766   {
19767     try {
19768       delete arg1;
19769     } catch (std::out_of_range& e) {
19770       {
19771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19772       };
19773     } catch (std::exception& e) {
19774       {
19775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19776       };
19777     } catch (...) {
19778       {
19779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19780       };
19781     }
19782   }
19783 }
19784
19785
19786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19787   void * jresult ;
19788   Dali::TypeRegistration *arg1 = 0 ;
19789   std::string *arg2 = 0 ;
19790   Dali::Property::Index arg3 ;
19791   Dali::Property::Type arg4 ;
19792   Dali::AnimatablePropertyRegistration *result = 0 ;
19793
19794   arg1 = (Dali::TypeRegistration *)jarg1;
19795   if (!arg1) {
19796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19797     return 0;
19798   }
19799   if (!jarg2) {
19800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19801     return 0;
19802   }
19803   std::string arg2_str(jarg2);
19804   arg2 = &arg2_str;
19805   arg3 = (Dali::Property::Index)jarg3;
19806   arg4 = (Dali::Property::Type)jarg4;
19807   {
19808     try {
19809       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19810     } catch (std::out_of_range& e) {
19811       {
19812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19813       };
19814     } catch (std::exception& e) {
19815       {
19816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19817       };
19818     } catch (...) {
19819       {
19820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19821       };
19822     }
19823   }
19824   jresult = (void *)result;
19825
19826   //argout typemap for const std::string&
19827
19828   return jresult;
19829 }
19830
19831
19832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
19833   void * jresult ;
19834   Dali::TypeRegistration *arg1 = 0 ;
19835   std::string *arg2 = 0 ;
19836   Dali::Property::Index arg3 ;
19837   Dali::Property::Value *arg4 = 0 ;
19838   Dali::AnimatablePropertyRegistration *result = 0 ;
19839
19840   arg1 = (Dali::TypeRegistration *)jarg1;
19841   if (!arg1) {
19842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19843     return 0;
19844   }
19845   if (!jarg2) {
19846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19847     return 0;
19848   }
19849   std::string arg2_str(jarg2);
19850   arg2 = &arg2_str;
19851   arg3 = (Dali::Property::Index)jarg3;
19852   arg4 = (Dali::Property::Value *)jarg4;
19853   if (!arg4) {
19854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
19855     return 0;
19856   }
19857   {
19858     try {
19859       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
19860     } catch (std::out_of_range& e) {
19861       {
19862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19863       };
19864     } catch (std::exception& e) {
19865       {
19866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19867       };
19868     } catch (...) {
19869       {
19870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19871       };
19872     }
19873   }
19874   jresult = (void *)result;
19875
19876   //argout typemap for const std::string&
19877
19878   return jresult;
19879 }
19880
19881
19882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
19883   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
19884
19885   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
19886   {
19887     try {
19888       delete arg1;
19889     } catch (std::out_of_range& e) {
19890       {
19891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19892       };
19893     } catch (std::exception& e) {
19894       {
19895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19896       };
19897     } catch (...) {
19898       {
19899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19900       };
19901     }
19902   }
19903 }
19904
19905
19906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
19907   void * jresult ;
19908   Dali::TypeRegistration *arg1 = 0 ;
19909   std::string *arg2 = 0 ;
19910   Dali::Property::Index arg3 ;
19911   Dali::Property::Index arg4 ;
19912   unsigned int arg5 ;
19913   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
19914
19915   arg1 = (Dali::TypeRegistration *)jarg1;
19916   if (!arg1) {
19917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19918     return 0;
19919   }
19920   if (!jarg2) {
19921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19922     return 0;
19923   }
19924   std::string arg2_str(jarg2);
19925   arg2 = &arg2_str;
19926   arg3 = (Dali::Property::Index)jarg3;
19927   arg4 = (Dali::Property::Index)jarg4;
19928   arg5 = (unsigned int)jarg5;
19929   {
19930     try {
19931       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
19932     } catch (std::out_of_range& e) {
19933       {
19934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19935       };
19936     } catch (std::exception& e) {
19937       {
19938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19939       };
19940     } catch (...) {
19941       {
19942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19943       };
19944     }
19945   }
19946   jresult = (void *)result;
19947
19948   //argout typemap for const std::string&
19949
19950   return jresult;
19951 }
19952
19953
19954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
19955   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
19956
19957   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
19958   {
19959     try {
19960       delete arg1;
19961     } catch (std::out_of_range& e) {
19962       {
19963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19964       };
19965     } catch (std::exception& e) {
19966       {
19967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19968       };
19969     } catch (...) {
19970       {
19971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19972       };
19973     }
19974   }
19975 }
19976
19977
19978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19979   void * jresult ;
19980   Dali::TypeRegistration *arg1 = 0 ;
19981   std::string *arg2 = 0 ;
19982   Dali::Property::Index arg3 ;
19983   Dali::Property::Type arg4 ;
19984   Dali::ChildPropertyRegistration *result = 0 ;
19985
19986   arg1 = (Dali::TypeRegistration *)jarg1;
19987   if (!arg1) {
19988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19989     return 0;
19990   }
19991   if (!jarg2) {
19992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19993     return 0;
19994   }
19995   std::string arg2_str(jarg2);
19996   arg2 = &arg2_str;
19997   arg3 = (Dali::Property::Index)jarg3;
19998   arg4 = (Dali::Property::Type)jarg4;
19999   {
20000     try {
20001       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
20002     } catch (std::out_of_range& e) {
20003       {
20004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20005       };
20006     } catch (std::exception& e) {
20007       {
20008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20009       };
20010     } catch (...) {
20011       {
20012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20013       };
20014     }
20015   }
20016   jresult = (void *)result;
20017
20018   //argout typemap for const std::string&
20019
20020   return jresult;
20021 }
20022
20023
20024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
20025   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
20026
20027   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
20028   {
20029     try {
20030       delete arg1;
20031     } catch (std::out_of_range& e) {
20032       {
20033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20034       };
20035     } catch (std::exception& e) {
20036       {
20037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20038       };
20039     } catch (...) {
20040       {
20041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20042       };
20043     }
20044   }
20045 }
20046
20047
20048 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
20049   unsigned int jresult ;
20050   std::string *arg1 = 0 ;
20051   std::type_info *arg2 = 0 ;
20052   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
20053   bool result;
20054
20055   if (!jarg1) {
20056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20057     return 0;
20058   }
20059   std::string arg1_str(jarg1);
20060   arg1 = &arg1_str;
20061   arg2 = (std::type_info *)jarg2;
20062   if (!arg2) {
20063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
20064     return 0;
20065   }
20066   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
20067   {
20068     try {
20069       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
20070     } catch (std::out_of_range& e) {
20071       {
20072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20073       };
20074     } catch (std::exception& e) {
20075       {
20076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20077       };
20078     } catch (...) {
20079       {
20080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20081       };
20082     }
20083   }
20084   jresult = result;
20085
20086   //argout typemap for const std::string&
20087
20088   return jresult;
20089 }
20090
20091
20092 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
20093   unsigned int jresult ;
20094   std::string *arg1 = 0 ;
20095   std::string *arg2 = 0 ;
20096   Dali::Property::Index arg3 ;
20097   Dali::Property::Type arg4 ;
20098   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
20099   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
20100   bool result;
20101
20102   if (!jarg1) {
20103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20104     return 0;
20105   }
20106   std::string arg1_str(jarg1);
20107   arg1 = &arg1_str;
20108   if (!jarg2) {
20109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20110     return 0;
20111   }
20112   std::string arg2_str(jarg2);
20113   arg2 = &arg2_str;
20114   arg3 = (Dali::Property::Index)jarg3;
20115   arg4 = (Dali::Property::Type)jarg4;
20116   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
20117   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
20118   {
20119     try {
20120       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
20121     } catch (std::out_of_range& e) {
20122       {
20123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20124       };
20125     } catch (std::exception& e) {
20126       {
20127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20128       };
20129     } catch (...) {
20130       {
20131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20132       };
20133     }
20134   }
20135   jresult = result;
20136
20137   //argout typemap for const std::string&
20138
20139
20140   //argout typemap for const std::string&
20141
20142   return jresult;
20143 }
20144
20145
20146 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
20147   float jresult ;
20148   float result;
20149
20150   result = (float)(float)Dali::ParentOrigin::TOP;
20151   jresult = result;
20152   return jresult;
20153 }
20154
20155
20156 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
20157   float jresult ;
20158   float result;
20159
20160   result = (float)(float)Dali::ParentOrigin::BOTTOM;
20161   jresult = result;
20162   return jresult;
20163 }
20164
20165
20166 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
20167   float jresult ;
20168   float result;
20169
20170   result = (float)(float)Dali::ParentOrigin::LEFT;
20171   jresult = result;
20172   return jresult;
20173 }
20174
20175
20176 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
20177   float jresult ;
20178   float result;
20179
20180   result = (float)(float)Dali::ParentOrigin::RIGHT;
20181   jresult = result;
20182   return jresult;
20183 }
20184
20185
20186 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
20187   float jresult ;
20188   float result;
20189
20190   result = (float)(float)Dali::ParentOrigin::MIDDLE;
20191   jresult = result;
20192   return jresult;
20193 }
20194
20195
20196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
20197   void * jresult ;
20198   Dali::Vector3 *result = 0 ;
20199
20200   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
20201   jresult = (void *)result;
20202   return jresult;
20203 }
20204
20205
20206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
20207   void * jresult ;
20208   Dali::Vector3 *result = 0 ;
20209
20210   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
20211   jresult = (void *)result;
20212   return jresult;
20213 }
20214
20215
20216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
20217   void * jresult ;
20218   Dali::Vector3 *result = 0 ;
20219
20220   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
20221   jresult = (void *)result;
20222   return jresult;
20223 }
20224
20225
20226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
20227   void * jresult ;
20228   Dali::Vector3 *result = 0 ;
20229
20230   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
20231   jresult = (void *)result;
20232   return jresult;
20233 }
20234
20235
20236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
20237   void * jresult ;
20238   Dali::Vector3 *result = 0 ;
20239
20240   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
20241   jresult = (void *)result;
20242   return jresult;
20243 }
20244
20245
20246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
20247   void * jresult ;
20248   Dali::Vector3 *result = 0 ;
20249
20250   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
20251   jresult = (void *)result;
20252   return jresult;
20253 }
20254
20255
20256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
20257   void * jresult ;
20258   Dali::Vector3 *result = 0 ;
20259
20260   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
20261   jresult = (void *)result;
20262   return jresult;
20263 }
20264
20265
20266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
20267   void * jresult ;
20268   Dali::Vector3 *result = 0 ;
20269
20270   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
20271   jresult = (void *)result;
20272   return jresult;
20273 }
20274
20275
20276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
20277   void * jresult ;
20278   Dali::Vector3 *result = 0 ;
20279
20280   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
20281   jresult = (void *)result;
20282   return jresult;
20283 }
20284
20285
20286 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
20287   float jresult ;
20288   float result;
20289
20290   result = (float)(float)Dali::AnchorPoint::TOP;
20291   jresult = result;
20292   return jresult;
20293 }
20294
20295
20296 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
20297   float jresult ;
20298   float result;
20299
20300   result = (float)(float)Dali::AnchorPoint::BOTTOM;
20301   jresult = result;
20302   return jresult;
20303 }
20304
20305
20306 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
20307   float jresult ;
20308   float result;
20309
20310   result = (float)(float)Dali::AnchorPoint::LEFT;
20311   jresult = result;
20312   return jresult;
20313 }
20314
20315
20316 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
20317   float jresult ;
20318   float result;
20319
20320   result = (float)(float)Dali::AnchorPoint::RIGHT;
20321   jresult = result;
20322   return jresult;
20323 }
20324
20325
20326 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
20327   float jresult ;
20328   float result;
20329
20330   result = (float)(float)Dali::AnchorPoint::MIDDLE;
20331   jresult = result;
20332   return jresult;
20333 }
20334
20335
20336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
20337   void * jresult ;
20338   Dali::Vector3 *result = 0 ;
20339
20340   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
20341   jresult = (void *)result;
20342   return jresult;
20343 }
20344
20345
20346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
20347   void * jresult ;
20348   Dali::Vector3 *result = 0 ;
20349
20350   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
20351   jresult = (void *)result;
20352   return jresult;
20353 }
20354
20355
20356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
20357   void * jresult ;
20358   Dali::Vector3 *result = 0 ;
20359
20360   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
20361   jresult = (void *)result;
20362   return jresult;
20363 }
20364
20365
20366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
20367   void * jresult ;
20368   Dali::Vector3 *result = 0 ;
20369
20370   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
20371   jresult = (void *)result;
20372   return jresult;
20373 }
20374
20375
20376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
20377   void * jresult ;
20378   Dali::Vector3 *result = 0 ;
20379
20380   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
20381   jresult = (void *)result;
20382   return jresult;
20383 }
20384
20385
20386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
20387   void * jresult ;
20388   Dali::Vector3 *result = 0 ;
20389
20390   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
20391   jresult = (void *)result;
20392   return jresult;
20393 }
20394
20395
20396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
20397   void * jresult ;
20398   Dali::Vector3 *result = 0 ;
20399
20400   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
20401   jresult = (void *)result;
20402   return jresult;
20403 }
20404
20405
20406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
20407   void * jresult ;
20408   Dali::Vector3 *result = 0 ;
20409
20410   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
20411   jresult = (void *)result;
20412   return jresult;
20413 }
20414
20415
20416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
20417   void * jresult ;
20418   Dali::Vector3 *result = 0 ;
20419
20420   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
20421   jresult = (void *)result;
20422   return jresult;
20423 }
20424
20425
20426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
20427   void * jresult ;
20428   Dali::Vector4 *result = 0 ;
20429
20430   result = (Dali::Vector4 *)&Dali::Color::BLACK;
20431   jresult = (void *)result;
20432   return jresult;
20433 }
20434
20435
20436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
20437   void * jresult ;
20438   Dali::Vector4 *result = 0 ;
20439
20440   result = (Dali::Vector4 *)&Dali::Color::WHITE;
20441   jresult = (void *)result;
20442   return jresult;
20443 }
20444
20445
20446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
20447   void * jresult ;
20448   Dali::Vector4 *result = 0 ;
20449
20450   result = (Dali::Vector4 *)&Dali::Color::RED;
20451   jresult = (void *)result;
20452   return jresult;
20453 }
20454
20455
20456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
20457   void * jresult ;
20458   Dali::Vector4 *result = 0 ;
20459
20460   result = (Dali::Vector4 *)&Dali::Color::GREEN;
20461   jresult = (void *)result;
20462   return jresult;
20463 }
20464
20465
20466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
20467   void * jresult ;
20468   Dali::Vector4 *result = 0 ;
20469
20470   result = (Dali::Vector4 *)&Dali::Color::BLUE;
20471   jresult = (void *)result;
20472   return jresult;
20473 }
20474
20475
20476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
20477   void * jresult ;
20478   Dali::Vector4 *result = 0 ;
20479
20480   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
20481   jresult = (void *)result;
20482   return jresult;
20483 }
20484
20485
20486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
20487   void * jresult ;
20488   Dali::Vector4 *result = 0 ;
20489
20490   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
20491   jresult = (void *)result;
20492   return jresult;
20493 }
20494
20495
20496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
20497   void * jresult ;
20498   Dali::Vector4 *result = 0 ;
20499
20500   result = (Dali::Vector4 *)&Dali::Color::CYAN;
20501   jresult = (void *)result;
20502   return jresult;
20503 }
20504
20505
20506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
20507   void * jresult ;
20508   Dali::Vector4 *result = 0 ;
20509
20510   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
20511   jresult = (void *)result;
20512   return jresult;
20513 }
20514
20515
20516 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
20517   float jresult ;
20518   float result;
20519
20520   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
20521   jresult = result;
20522   return jresult;
20523 }
20524
20525
20526 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
20527   float jresult ;
20528   float result;
20529
20530   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
20531   jresult = result;
20532   return jresult;
20533 }
20534
20535
20536 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
20537   float jresult ;
20538   float result;
20539
20540   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
20541   jresult = result;
20542   return jresult;
20543 }
20544
20545
20546 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
20547   float jresult ;
20548   float result;
20549
20550   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
20551   jresult = result;
20552   return jresult;
20553 }
20554
20555
20556 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
20557   float jresult ;
20558   float result;
20559
20560   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
20561   jresult = result;
20562   return jresult;
20563 }
20564
20565
20566 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
20567   float jresult ;
20568   float result;
20569
20570   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
20571   jresult = result;
20572   return jresult;
20573 }
20574
20575
20576 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
20577   float jresult ;
20578   float result;
20579
20580   result = (float)(float)Dali::Math::PI;
20581   jresult = result;
20582   return jresult;
20583 }
20584
20585
20586 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
20587   float jresult ;
20588   float result;
20589
20590   result = (float)(float)Dali::Math::PI_2;
20591   jresult = result;
20592   return jresult;
20593 }
20594
20595
20596 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
20597   float jresult ;
20598   float result;
20599
20600   result = (float)(float)Dali::Math::PI_4;
20601   jresult = result;
20602   return jresult;
20603 }
20604
20605
20606 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
20607   float jresult ;
20608   float result;
20609
20610   result = (float)(float)Dali::Math::PI_OVER_180;
20611   jresult = result;
20612   return jresult;
20613 }
20614
20615
20616 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
20617   float jresult ;
20618   float result;
20619
20620   result = (float)(float)Dali::Math::ONE80_OVER_PI;
20621   jresult = result;
20622   return jresult;
20623 }
20624
20625
20626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
20627   int jresult ;
20628   Dali::ResizePolicy::Type result;
20629
20630   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
20631   jresult = (int)result;
20632   return jresult;
20633 }
20634
20635
20636 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
20637   unsigned long jresult ;
20638   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20639   Dali::VectorBase::SizeType result;
20640
20641   arg1 = (Dali::VectorBase *)jarg1;
20642   {
20643     try {
20644       result = ((Dali::VectorBase const *)arg1)->Count();
20645     } catch (std::out_of_range& e) {
20646       {
20647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20648       };
20649     } catch (std::exception& e) {
20650       {
20651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20652       };
20653     } catch (...) {
20654       {
20655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20656       };
20657     }
20658   }
20659   jresult = (unsigned long)result;
20660   return jresult;
20661 }
20662
20663
20664 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
20665   unsigned long jresult ;
20666   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20667   Dali::VectorBase::SizeType result;
20668
20669   arg1 = (Dali::VectorBase *)jarg1;
20670   {
20671     try {
20672       result = ((Dali::VectorBase const *)arg1)->Size();
20673     } catch (std::out_of_range& e) {
20674       {
20675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20676       };
20677     } catch (std::exception& e) {
20678       {
20679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20680       };
20681     } catch (...) {
20682       {
20683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20684       };
20685     }
20686   }
20687   jresult = (unsigned long)result;
20688   return jresult;
20689 }
20690
20691
20692 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
20693   unsigned int jresult ;
20694   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20695   bool result;
20696
20697   arg1 = (Dali::VectorBase *)jarg1;
20698   {
20699     try {
20700       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
20701     } catch (std::out_of_range& e) {
20702       {
20703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20704       };
20705     } catch (std::exception& e) {
20706       {
20707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20708       };
20709     } catch (...) {
20710       {
20711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20712       };
20713     }
20714   }
20715   jresult = result;
20716   return jresult;
20717 }
20718
20719
20720 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
20721   unsigned long jresult ;
20722   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20723   Dali::VectorBase::SizeType result;
20724
20725   arg1 = (Dali::VectorBase *)jarg1;
20726   {
20727     try {
20728       result = ((Dali::VectorBase const *)arg1)->Capacity();
20729     } catch (std::out_of_range& e) {
20730       {
20731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20732       };
20733     } catch (std::exception& e) {
20734       {
20735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20736       };
20737     } catch (...) {
20738       {
20739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20740       };
20741     }
20742   }
20743   jresult = (unsigned long)result;
20744   return jresult;
20745 }
20746
20747
20748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
20749   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20750
20751   arg1 = (Dali::VectorBase *)jarg1;
20752   {
20753     try {
20754       (arg1)->Release();
20755     } catch (std::out_of_range& e) {
20756       {
20757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20758       };
20759     } catch (std::exception& e) {
20760       {
20761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20762       };
20763     } catch (...) {
20764       {
20765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20766       };
20767     }
20768   }
20769 }
20770
20771
20772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
20773   void * jresult ;
20774   Dali::Image *result = 0 ;
20775
20776   {
20777     try {
20778       result = (Dali::Image *)new Dali::Image();
20779     } catch (std::out_of_range& e) {
20780       {
20781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20782       };
20783     } catch (std::exception& e) {
20784       {
20785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20786       };
20787     } catch (...) {
20788       {
20789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20790       };
20791     }
20792   }
20793   jresult = (void *)result;
20794   return jresult;
20795 }
20796
20797
20798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
20799   Dali::Image *arg1 = (Dali::Image *) 0 ;
20800
20801   arg1 = (Dali::Image *)jarg1;
20802   {
20803     try {
20804       delete arg1;
20805     } catch (std::out_of_range& e) {
20806       {
20807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20808       };
20809     } catch (std::exception& e) {
20810       {
20811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20812       };
20813     } catch (...) {
20814       {
20815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20816       };
20817     }
20818   }
20819 }
20820
20821
20822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
20823   void * jresult ;
20824   Dali::Image *arg1 = 0 ;
20825   Dali::Image *result = 0 ;
20826
20827   arg1 = (Dali::Image *)jarg1;
20828   if (!arg1) {
20829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20830     return 0;
20831   }
20832   {
20833     try {
20834       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
20835     } catch (std::out_of_range& e) {
20836       {
20837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20838       };
20839     } catch (std::exception& e) {
20840       {
20841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20842       };
20843     } catch (...) {
20844       {
20845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20846       };
20847     }
20848   }
20849   jresult = (void *)result;
20850   return jresult;
20851 }
20852
20853
20854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
20855   void * jresult ;
20856   Dali::Image *arg1 = (Dali::Image *) 0 ;
20857   Dali::Image *arg2 = 0 ;
20858   Dali::Image *result = 0 ;
20859
20860   arg1 = (Dali::Image *)jarg1;
20861   arg2 = (Dali::Image *)jarg2;
20862   if (!arg2) {
20863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20864     return 0;
20865   }
20866   {
20867     try {
20868       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
20869     } catch (std::out_of_range& e) {
20870       {
20871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20872       };
20873     } catch (std::exception& e) {
20874       {
20875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20876       };
20877     } catch (...) {
20878       {
20879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20880       };
20881     }
20882   }
20883   jresult = (void *)result;
20884   return jresult;
20885 }
20886
20887
20888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
20889   void * jresult ;
20890   Dali::BaseHandle arg1 ;
20891   Dali::BaseHandle *argp1 ;
20892   Dali::Image result;
20893
20894   argp1 = (Dali::BaseHandle *)jarg1;
20895   if (!argp1) {
20896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20897     return 0;
20898   }
20899   arg1 = *argp1;
20900   {
20901     try {
20902       result = Dali::Image::DownCast(arg1);
20903     } catch (std::out_of_range& e) {
20904       {
20905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20906       };
20907     } catch (std::exception& e) {
20908       {
20909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20910       };
20911     } catch (...) {
20912       {
20913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20914       };
20915     }
20916   }
20917   jresult = new Dali::Image((const Dali::Image &)result);
20918   return jresult;
20919 }
20920
20921
20922 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
20923   unsigned int jresult ;
20924   Dali::Image *arg1 = (Dali::Image *) 0 ;
20925   unsigned int result;
20926
20927   arg1 = (Dali::Image *)jarg1;
20928   {
20929     try {
20930       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
20931     } catch (std::out_of_range& e) {
20932       {
20933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20934       };
20935     } catch (std::exception& e) {
20936       {
20937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20938       };
20939     } catch (...) {
20940       {
20941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20942       };
20943     }
20944   }
20945   jresult = result;
20946   return jresult;
20947 }
20948
20949
20950 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
20951   unsigned int jresult ;
20952   Dali::Image *arg1 = (Dali::Image *) 0 ;
20953   unsigned int result;
20954
20955   arg1 = (Dali::Image *)jarg1;
20956   {
20957     try {
20958       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
20959     } catch (std::out_of_range& e) {
20960       {
20961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20962       };
20963     } catch (std::exception& e) {
20964       {
20965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20966       };
20967     } catch (...) {
20968       {
20969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20970       };
20971     }
20972   }
20973   jresult = result;
20974   return jresult;
20975 }
20976
20977
20978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
20979   void * jresult ;
20980   Dali::Image *arg1 = (Dali::Image *) 0 ;
20981   Dali::Image::ImageSignalType *result = 0 ;
20982
20983   arg1 = (Dali::Image *)jarg1;
20984   {
20985     try {
20986       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
20987     } catch (std::out_of_range& e) {
20988       {
20989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20990       };
20991     } catch (std::exception& e) {
20992       {
20993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20994       };
20995     } catch (...) {
20996       {
20997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20998       };
20999     }
21000   }
21001   jresult = (void *)result;
21002   return jresult;
21003 }
21004
21005
21006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
21007   int jresult ;
21008   Dali::Pixel::Format result;
21009
21010   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
21011   jresult = (int)result;
21012   return jresult;
21013 }
21014
21015
21016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
21017   int jresult ;
21018   Dali::Pixel::Format result;
21019
21020   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
21021   jresult = (int)result;
21022   return jresult;
21023 }
21024
21025
21026 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
21027   unsigned int jresult ;
21028   Dali::Pixel::Format arg1 ;
21029   bool result;
21030
21031   arg1 = (Dali::Pixel::Format)jarg1;
21032   {
21033     try {
21034       result = (bool)Dali::Pixel::HasAlpha(arg1);
21035     } catch (std::out_of_range& e) {
21036       {
21037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21038       };
21039     } catch (std::exception& e) {
21040       {
21041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21042       };
21043     } catch (...) {
21044       {
21045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21046       };
21047     }
21048   }
21049   jresult = result;
21050   return jresult;
21051 }
21052
21053
21054 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
21055   unsigned int jresult ;
21056   Dali::Pixel::Format arg1 ;
21057   unsigned int result;
21058
21059   arg1 = (Dali::Pixel::Format)jarg1;
21060   {
21061     try {
21062       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
21063     } catch (std::out_of_range& e) {
21064       {
21065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21066       };
21067     } catch (std::exception& e) {
21068       {
21069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21070       };
21071     } catch (...) {
21072       {
21073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21074       };
21075     }
21076   }
21077   jresult = result;
21078   return jresult;
21079 }
21080
21081
21082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
21083   Dali::Pixel::Format arg1 ;
21084   int *arg2 = 0 ;
21085   int *arg3 = 0 ;
21086
21087   arg1 = (Dali::Pixel::Format)jarg1;
21088   arg2 = (int *)jarg2;
21089   if (!arg2) {
21090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21091     return ;
21092   }
21093   arg3 = (int *)jarg3;
21094   if (!arg3) {
21095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21096     return ;
21097   }
21098   {
21099     try {
21100       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
21101     } catch (std::out_of_range& e) {
21102       {
21103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21104       };
21105     } catch (std::exception& e) {
21106       {
21107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21108       };
21109     } catch (...) {
21110       {
21111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21112       };
21113     }
21114   }
21115 }
21116
21117
21118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
21119   void * jresult ;
21120   unsigned char *arg1 = (unsigned char *) 0 ;
21121   unsigned int arg2 ;
21122   unsigned int arg3 ;
21123   unsigned int arg4 ;
21124   Dali::Pixel::Format arg5 ;
21125   Dali::PixelData::ReleaseFunction arg6 ;
21126   Dali::PixelData result;
21127
21128   arg1 = jarg1;
21129   arg2 = (unsigned int)jarg2;
21130   arg3 = (unsigned int)jarg3;
21131   arg4 = (unsigned int)jarg4;
21132   arg5 = (Dali::Pixel::Format)jarg5;
21133   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
21134   {
21135     try {
21136       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
21137     } catch (std::out_of_range& e) {
21138       {
21139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21140       };
21141     } catch (std::exception& e) {
21142       {
21143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21144       };
21145     } catch (...) {
21146       {
21147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21148       };
21149     }
21150   }
21151   jresult = new Dali::PixelData((const Dali::PixelData &)result);
21152
21153
21154   return jresult;
21155 }
21156
21157
21158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
21159   void * jresult ;
21160   Dali::PixelData *result = 0 ;
21161
21162   {
21163     try {
21164       result = (Dali::PixelData *)new Dali::PixelData();
21165     } catch (std::out_of_range& e) {
21166       {
21167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21168       };
21169     } catch (std::exception& e) {
21170       {
21171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21172       };
21173     } catch (...) {
21174       {
21175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21176       };
21177     }
21178   }
21179   jresult = (void *)result;
21180   return jresult;
21181 }
21182
21183
21184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
21185   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21186
21187   arg1 = (Dali::PixelData *)jarg1;
21188   {
21189     try {
21190       delete arg1;
21191     } catch (std::out_of_range& e) {
21192       {
21193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21194       };
21195     } catch (std::exception& e) {
21196       {
21197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21198       };
21199     } catch (...) {
21200       {
21201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21202       };
21203     }
21204   }
21205 }
21206
21207
21208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
21209   void * jresult ;
21210   Dali::PixelData *arg1 = 0 ;
21211   Dali::PixelData *result = 0 ;
21212
21213   arg1 = (Dali::PixelData *)jarg1;
21214   if (!arg1) {
21215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21216     return 0;
21217   }
21218   {
21219     try {
21220       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
21221     } catch (std::out_of_range& e) {
21222       {
21223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21224       };
21225     } catch (std::exception& e) {
21226       {
21227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21228       };
21229     } catch (...) {
21230       {
21231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21232       };
21233     }
21234   }
21235   jresult = (void *)result;
21236   return jresult;
21237 }
21238
21239
21240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
21241   void * jresult ;
21242   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21243   Dali::PixelData *arg2 = 0 ;
21244   Dali::PixelData *result = 0 ;
21245
21246   arg1 = (Dali::PixelData *)jarg1;
21247   arg2 = (Dali::PixelData *)jarg2;
21248   if (!arg2) {
21249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21250     return 0;
21251   }
21252   {
21253     try {
21254       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
21255     } catch (std::out_of_range& e) {
21256       {
21257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21258       };
21259     } catch (std::exception& e) {
21260       {
21261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21262       };
21263     } catch (...) {
21264       {
21265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21266       };
21267     }
21268   }
21269   jresult = (void *)result;
21270   return jresult;
21271 }
21272
21273
21274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
21275   unsigned int jresult ;
21276   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21277   unsigned int result;
21278
21279   arg1 = (Dali::PixelData *)jarg1;
21280   {
21281     try {
21282       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
21283     } catch (std::out_of_range& e) {
21284       {
21285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21286       };
21287     } catch (std::exception& e) {
21288       {
21289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21290       };
21291     } catch (...) {
21292       {
21293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21294       };
21295     }
21296   }
21297   jresult = result;
21298   return jresult;
21299 }
21300
21301
21302 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
21303   unsigned int jresult ;
21304   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21305   unsigned int result;
21306
21307   arg1 = (Dali::PixelData *)jarg1;
21308   {
21309     try {
21310       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
21311     } catch (std::out_of_range& e) {
21312       {
21313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21314       };
21315     } catch (std::exception& e) {
21316       {
21317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21318       };
21319     } catch (...) {
21320       {
21321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21322       };
21323     }
21324   }
21325   jresult = result;
21326   return jresult;
21327 }
21328
21329
21330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
21331   int jresult ;
21332   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21333   Dali::Pixel::Format result;
21334
21335   arg1 = (Dali::PixelData *)jarg1;
21336   {
21337     try {
21338       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
21339     } catch (std::out_of_range& e) {
21340       {
21341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21342       };
21343     } catch (std::exception& e) {
21344       {
21345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21346       };
21347     } catch (...) {
21348       {
21349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21350       };
21351     }
21352   }
21353   jresult = (int)result;
21354   return jresult;
21355 }
21356
21357
21358 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
21359   unsigned int jresult ;
21360   unsigned int result;
21361
21362   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
21363   jresult = result;
21364   return jresult;
21365 }
21366
21367
21368 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
21369   unsigned int jresult ;
21370   unsigned int result;
21371
21372   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
21373   jresult = result;
21374   return jresult;
21375 }
21376
21377
21378 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
21379   unsigned int jresult ;
21380   unsigned int result;
21381
21382   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
21383   jresult = result;
21384   return jresult;
21385 }
21386
21387
21388 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
21389   unsigned int jresult ;
21390   unsigned int result;
21391
21392   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
21393   jresult = result;
21394   return jresult;
21395 }
21396
21397
21398 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
21399   unsigned int jresult ;
21400   unsigned int result;
21401
21402   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
21403   jresult = result;
21404   return jresult;
21405 }
21406
21407
21408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
21409   unsigned int jresult ;
21410   unsigned int result;
21411
21412   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
21413   jresult = result;
21414   return jresult;
21415 }
21416
21417
21418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
21419   void * jresult ;
21420   Dali::TextureType::Type arg1 ;
21421   Dali::Pixel::Format arg2 ;
21422   unsigned int arg3 ;
21423   unsigned int arg4 ;
21424   Dali::Texture result;
21425
21426   arg1 = (Dali::TextureType::Type)jarg1;
21427   arg2 = (Dali::Pixel::Format)jarg2;
21428   arg3 = (unsigned int)jarg3;
21429   arg4 = (unsigned int)jarg4;
21430   {
21431     try {
21432       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
21433     } catch (std::out_of_range& e) {
21434       {
21435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21436       };
21437     } catch (std::exception& e) {
21438       {
21439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21440       };
21441     } catch (...) {
21442       {
21443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21444       };
21445     }
21446   }
21447   jresult = new Dali::Texture((const Dali::Texture &)result);
21448   return jresult;
21449 }
21450
21451
21452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
21453   void * jresult ;
21454   NativeImageInterface *arg1 = 0 ;
21455   Dali::Texture result;
21456
21457   arg1 = (NativeImageInterface *)jarg1;
21458   if (!arg1) {
21459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
21460     return 0;
21461   }
21462   {
21463     try {
21464       result = Dali::Texture::New(*arg1);
21465     } catch (std::out_of_range& e) {
21466       {
21467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21468       };
21469     } catch (std::exception& e) {
21470       {
21471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21472       };
21473     } catch (...) {
21474       {
21475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21476       };
21477     }
21478   }
21479   jresult = new Dali::Texture((const Dali::Texture &)result);
21480   return jresult;
21481 }
21482
21483
21484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
21485   void * jresult ;
21486   Dali::Texture *result = 0 ;
21487
21488   {
21489     try {
21490       result = (Dali::Texture *)new Dali::Texture();
21491     } catch (std::out_of_range& e) {
21492       {
21493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21494       };
21495     } catch (std::exception& e) {
21496       {
21497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21498       };
21499     } catch (...) {
21500       {
21501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21502       };
21503     }
21504   }
21505   jresult = (void *)result;
21506   return jresult;
21507 }
21508
21509
21510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
21511   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21512
21513   arg1 = (Dali::Texture *)jarg1;
21514   {
21515     try {
21516       delete arg1;
21517     } catch (std::out_of_range& e) {
21518       {
21519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21520       };
21521     } catch (std::exception& e) {
21522       {
21523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21524       };
21525     } catch (...) {
21526       {
21527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21528       };
21529     }
21530   }
21531 }
21532
21533
21534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
21535   void * jresult ;
21536   Dali::Texture *arg1 = 0 ;
21537   Dali::Texture *result = 0 ;
21538
21539   arg1 = (Dali::Texture *)jarg1;
21540   if (!arg1) {
21541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21542     return 0;
21543   }
21544   {
21545     try {
21546       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
21547     } catch (std::out_of_range& e) {
21548       {
21549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21550       };
21551     } catch (std::exception& e) {
21552       {
21553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21554       };
21555     } catch (...) {
21556       {
21557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21558       };
21559     }
21560   }
21561   jresult = (void *)result;
21562   return jresult;
21563 }
21564
21565
21566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
21567   void * jresult ;
21568   Dali::BaseHandle arg1 ;
21569   Dali::BaseHandle *argp1 ;
21570   Dali::Texture result;
21571
21572   argp1 = (Dali::BaseHandle *)jarg1;
21573   if (!argp1) {
21574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21575     return 0;
21576   }
21577   arg1 = *argp1;
21578   {
21579     try {
21580       result = Dali::Texture::DownCast(arg1);
21581     } catch (std::out_of_range& e) {
21582       {
21583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21584       };
21585     } catch (std::exception& e) {
21586       {
21587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21588       };
21589     } catch (...) {
21590       {
21591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21592       };
21593     }
21594   }
21595   jresult = new Dali::Texture((const Dali::Texture &)result);
21596   return jresult;
21597 }
21598
21599
21600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
21601   void * jresult ;
21602   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21603   Dali::Texture *arg2 = 0 ;
21604   Dali::Texture *result = 0 ;
21605
21606   arg1 = (Dali::Texture *)jarg1;
21607   arg2 = (Dali::Texture *)jarg2;
21608   if (!arg2) {
21609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21610     return 0;
21611   }
21612   {
21613     try {
21614       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
21615     } catch (std::out_of_range& e) {
21616       {
21617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21618       };
21619     } catch (std::exception& e) {
21620       {
21621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21622       };
21623     } catch (...) {
21624       {
21625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21626       };
21627     }
21628   }
21629   jresult = (void *)result;
21630   return jresult;
21631 }
21632
21633
21634 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
21635   unsigned int jresult ;
21636   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21637   Dali::PixelData arg2 ;
21638   Dali::PixelData *argp2 ;
21639   bool result;
21640
21641   arg1 = (Dali::Texture *)jarg1;
21642   argp2 = (Dali::PixelData *)jarg2;
21643   if (!argp2) {
21644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21645     return 0;
21646   }
21647   arg2 = *argp2;
21648   {
21649     try {
21650       result = (bool)(arg1)->Upload(arg2);
21651     } catch (std::out_of_range& e) {
21652       {
21653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21654       };
21655     } catch (std::exception& e) {
21656       {
21657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21658       };
21659     } catch (...) {
21660       {
21661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21662       };
21663     }
21664   }
21665   jresult = result;
21666   return jresult;
21667 }
21668
21669
21670 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) {
21671   unsigned int jresult ;
21672   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21673   Dali::PixelData arg2 ;
21674   unsigned int arg3 ;
21675   unsigned int arg4 ;
21676   unsigned int arg5 ;
21677   unsigned int arg6 ;
21678   unsigned int arg7 ;
21679   unsigned int arg8 ;
21680   Dali::PixelData *argp2 ;
21681   bool result;
21682
21683   arg1 = (Dali::Texture *)jarg1;
21684   argp2 = (Dali::PixelData *)jarg2;
21685   if (!argp2) {
21686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21687     return 0;
21688   }
21689   arg2 = *argp2;
21690   arg3 = (unsigned int)jarg3;
21691   arg4 = (unsigned int)jarg4;
21692   arg5 = (unsigned int)jarg5;
21693   arg6 = (unsigned int)jarg6;
21694   arg7 = (unsigned int)jarg7;
21695   arg8 = (unsigned int)jarg8;
21696   {
21697     try {
21698       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
21699     } catch (std::out_of_range& e) {
21700       {
21701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21702       };
21703     } catch (std::exception& e) {
21704       {
21705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21706       };
21707     } catch (...) {
21708       {
21709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21710       };
21711     }
21712   }
21713   jresult = result;
21714   return jresult;
21715 }
21716
21717
21718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
21719   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21720
21721   arg1 = (Dali::Texture *)jarg1;
21722   {
21723     try {
21724       (arg1)->GenerateMipmaps();
21725     } catch (std::out_of_range& e) {
21726       {
21727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21728       };
21729     } catch (std::exception& e) {
21730       {
21731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21732       };
21733     } catch (...) {
21734       {
21735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21736       };
21737     }
21738   }
21739 }
21740
21741
21742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
21743   unsigned int jresult ;
21744   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21745   unsigned int result;
21746
21747   arg1 = (Dali::Texture *)jarg1;
21748   {
21749     try {
21750       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
21751     } catch (std::out_of_range& e) {
21752       {
21753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21754       };
21755     } catch (std::exception& e) {
21756       {
21757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21758       };
21759     } catch (...) {
21760       {
21761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21762       };
21763     }
21764   }
21765   jresult = result;
21766   return jresult;
21767 }
21768
21769
21770 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
21771   unsigned int jresult ;
21772   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21773   unsigned int result;
21774
21775   arg1 = (Dali::Texture *)jarg1;
21776   {
21777     try {
21778       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
21779     } catch (std::out_of_range& e) {
21780       {
21781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21782       };
21783     } catch (std::exception& e) {
21784       {
21785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21786       };
21787     } catch (...) {
21788       {
21789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21790       };
21791     }
21792   }
21793   jresult = result;
21794   return jresult;
21795 }
21796
21797
21798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_2(void * jarg1) {
21799   void * jresult ;
21800   Dali::Internal::Texture *arg1 = (Dali::Internal::Texture *) 0 ;
21801   Dali::Texture *result = 0 ;
21802
21803   arg1 = (Dali::Internal::Texture *)jarg1;
21804   {
21805     try {
21806       result = (Dali::Texture *)new Dali::Texture(arg1);
21807     } catch (std::out_of_range& e) {
21808       {
21809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21810       };
21811     } catch (std::exception& e) {
21812       {
21813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21814       };
21815     } catch (...) {
21816       {
21817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21818       };
21819     }
21820   }
21821   jresult = (void *)result;
21822   return jresult;
21823 }
21824
21825
21826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
21827   void * jresult ;
21828   Dali::Sampler result;
21829
21830   {
21831     try {
21832       result = Dali::Sampler::New();
21833     } catch (std::out_of_range& e) {
21834       {
21835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21836       };
21837     } catch (std::exception& e) {
21838       {
21839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21840       };
21841     } catch (...) {
21842       {
21843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21844       };
21845     }
21846   }
21847   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21848   return jresult;
21849 }
21850
21851
21852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
21853   void * jresult ;
21854   Dali::Sampler *result = 0 ;
21855
21856   {
21857     try {
21858       result = (Dali::Sampler *)new Dali::Sampler();
21859     } catch (std::out_of_range& e) {
21860       {
21861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21862       };
21863     } catch (std::exception& e) {
21864       {
21865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21866       };
21867     } catch (...) {
21868       {
21869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21870       };
21871     }
21872   }
21873   jresult = (void *)result;
21874   return jresult;
21875 }
21876
21877
21878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
21879   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21880
21881   arg1 = (Dali::Sampler *)jarg1;
21882   {
21883     try {
21884       delete arg1;
21885     } catch (std::out_of_range& e) {
21886       {
21887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21888       };
21889     } catch (std::exception& e) {
21890       {
21891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21892       };
21893     } catch (...) {
21894       {
21895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21896       };
21897     }
21898   }
21899 }
21900
21901
21902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
21903   void * jresult ;
21904   Dali::Sampler *arg1 = 0 ;
21905   Dali::Sampler *result = 0 ;
21906
21907   arg1 = (Dali::Sampler *)jarg1;
21908   if (!arg1) {
21909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21910     return 0;
21911   }
21912   {
21913     try {
21914       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
21915     } catch (std::out_of_range& e) {
21916       {
21917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21918       };
21919     } catch (std::exception& e) {
21920       {
21921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21922       };
21923     } catch (...) {
21924       {
21925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21926       };
21927     }
21928   }
21929   jresult = (void *)result;
21930   return jresult;
21931 }
21932
21933
21934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
21935   void * jresult ;
21936   Dali::BaseHandle arg1 ;
21937   Dali::BaseHandle *argp1 ;
21938   Dali::Sampler result;
21939
21940   argp1 = (Dali::BaseHandle *)jarg1;
21941   if (!argp1) {
21942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21943     return 0;
21944   }
21945   arg1 = *argp1;
21946   {
21947     try {
21948       result = Dali::Sampler::DownCast(arg1);
21949     } catch (std::out_of_range& e) {
21950       {
21951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21952       };
21953     } catch (std::exception& e) {
21954       {
21955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21956       };
21957     } catch (...) {
21958       {
21959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21960       };
21961     }
21962   }
21963   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21964   return jresult;
21965 }
21966
21967
21968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
21969   void * jresult ;
21970   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21971   Dali::Sampler *arg2 = 0 ;
21972   Dali::Sampler *result = 0 ;
21973
21974   arg1 = (Dali::Sampler *)jarg1;
21975   arg2 = (Dali::Sampler *)jarg2;
21976   if (!arg2) {
21977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21978     return 0;
21979   }
21980   {
21981     try {
21982       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
21983     } catch (std::out_of_range& e) {
21984       {
21985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21986       };
21987     } catch (std::exception& e) {
21988       {
21989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21990       };
21991     } catch (...) {
21992       {
21993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21994       };
21995     }
21996   }
21997   jresult = (void *)result;
21998   return jresult;
21999 }
22000
22001
22002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
22003   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22004   Dali::FilterMode::Type arg2 ;
22005   Dali::FilterMode::Type arg3 ;
22006
22007   arg1 = (Dali::Sampler *)jarg1;
22008   arg2 = (Dali::FilterMode::Type)jarg2;
22009   arg3 = (Dali::FilterMode::Type)jarg3;
22010   {
22011     try {
22012       (arg1)->SetFilterMode(arg2,arg3);
22013     } catch (std::out_of_range& e) {
22014       {
22015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22016       };
22017     } catch (std::exception& e) {
22018       {
22019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22020       };
22021     } catch (...) {
22022       {
22023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22024       };
22025     }
22026   }
22027 }
22028
22029
22030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
22031   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22032   Dali::WrapMode::Type arg2 ;
22033   Dali::WrapMode::Type arg3 ;
22034
22035   arg1 = (Dali::Sampler *)jarg1;
22036   arg2 = (Dali::WrapMode::Type)jarg2;
22037   arg3 = (Dali::WrapMode::Type)jarg3;
22038   {
22039     try {
22040       (arg1)->SetWrapMode(arg2,arg3);
22041     } catch (std::out_of_range& e) {
22042       {
22043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22044       };
22045     } catch (std::exception& e) {
22046       {
22047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22048       };
22049     } catch (...) {
22050       {
22051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22052       };
22053     }
22054   }
22055 }
22056
22057
22058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
22059   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22060   Dali::WrapMode::Type arg2 ;
22061   Dali::WrapMode::Type arg3 ;
22062   Dali::WrapMode::Type arg4 ;
22063
22064   arg1 = (Dali::Sampler *)jarg1;
22065   arg2 = (Dali::WrapMode::Type)jarg2;
22066   arg3 = (Dali::WrapMode::Type)jarg3;
22067   arg4 = (Dali::WrapMode::Type)jarg4;
22068   {
22069     try {
22070       (arg1)->SetWrapMode(arg2,arg3,arg4);
22071     } catch (std::out_of_range& e) {
22072       {
22073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22074       };
22075     } catch (std::exception& e) {
22076       {
22077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22078       };
22079     } catch (...) {
22080       {
22081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22082       };
22083     }
22084   }
22085 }
22086
22087
22088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
22089   void * jresult ;
22090   Dali::TextureSet result;
22091
22092   {
22093     try {
22094       result = Dali::TextureSet::New();
22095     } catch (std::out_of_range& e) {
22096       {
22097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22098       };
22099     } catch (std::exception& e) {
22100       {
22101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22102       };
22103     } catch (...) {
22104       {
22105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22106       };
22107     }
22108   }
22109   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22110   return jresult;
22111 }
22112
22113
22114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
22115   void * jresult ;
22116   Dali::TextureSet *result = 0 ;
22117
22118   {
22119     try {
22120       result = (Dali::TextureSet *)new Dali::TextureSet();
22121     } catch (std::out_of_range& e) {
22122       {
22123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22124       };
22125     } catch (std::exception& e) {
22126       {
22127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22128       };
22129     } catch (...) {
22130       {
22131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22132       };
22133     }
22134   }
22135   jresult = (void *)result;
22136   return jresult;
22137 }
22138
22139
22140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
22141   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22142
22143   arg1 = (Dali::TextureSet *)jarg1;
22144   {
22145     try {
22146       delete arg1;
22147     } catch (std::out_of_range& e) {
22148       {
22149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22150       };
22151     } catch (std::exception& e) {
22152       {
22153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22154       };
22155     } catch (...) {
22156       {
22157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22158       };
22159     }
22160   }
22161 }
22162
22163
22164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
22165   void * jresult ;
22166   Dali::TextureSet *arg1 = 0 ;
22167   Dali::TextureSet *result = 0 ;
22168
22169   arg1 = (Dali::TextureSet *)jarg1;
22170   if (!arg1) {
22171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22172     return 0;
22173   }
22174   {
22175     try {
22176       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
22177     } catch (std::out_of_range& e) {
22178       {
22179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22180       };
22181     } catch (std::exception& e) {
22182       {
22183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22184       };
22185     } catch (...) {
22186       {
22187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22188       };
22189     }
22190   }
22191   jresult = (void *)result;
22192   return jresult;
22193 }
22194
22195
22196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
22197   void * jresult ;
22198   Dali::BaseHandle arg1 ;
22199   Dali::BaseHandle *argp1 ;
22200   Dali::TextureSet result;
22201
22202   argp1 = (Dali::BaseHandle *)jarg1;
22203   if (!argp1) {
22204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22205     return 0;
22206   }
22207   arg1 = *argp1;
22208   {
22209     try {
22210       result = Dali::TextureSet::DownCast(arg1);
22211     } catch (std::out_of_range& e) {
22212       {
22213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22214       };
22215     } catch (std::exception& e) {
22216       {
22217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22218       };
22219     } catch (...) {
22220       {
22221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22222       };
22223     }
22224   }
22225   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22226   return jresult;
22227 }
22228
22229
22230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
22231   void * jresult ;
22232   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22233   Dali::TextureSet *arg2 = 0 ;
22234   Dali::TextureSet *result = 0 ;
22235
22236   arg1 = (Dali::TextureSet *)jarg1;
22237   arg2 = (Dali::TextureSet *)jarg2;
22238   if (!arg2) {
22239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22240     return 0;
22241   }
22242   {
22243     try {
22244       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
22245     } catch (std::out_of_range& e) {
22246       {
22247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22248       };
22249     } catch (std::exception& e) {
22250       {
22251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22252       };
22253     } catch (...) {
22254       {
22255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22256       };
22257     }
22258   }
22259   jresult = (void *)result;
22260   return jresult;
22261 }
22262
22263
22264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
22265   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22266   size_t arg2 ;
22267   Dali::Texture arg3 ;
22268   Dali::Texture *argp3 ;
22269
22270   arg1 = (Dali::TextureSet *)jarg1;
22271   arg2 = (size_t)jarg2;
22272   argp3 = (Dali::Texture *)jarg3;
22273   if (!argp3) {
22274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
22275     return ;
22276   }
22277   arg3 = *argp3;
22278   {
22279     try {
22280       (arg1)->SetTexture(arg2,arg3);
22281     } catch (std::out_of_range& e) {
22282       {
22283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22284       };
22285     } catch (std::exception& e) {
22286       {
22287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22288       };
22289     } catch (...) {
22290       {
22291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22292       };
22293     }
22294   }
22295 }
22296
22297
22298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
22299   void * jresult ;
22300   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22301   size_t arg2 ;
22302   Dali::Texture result;
22303
22304   arg1 = (Dali::TextureSet *)jarg1;
22305   arg2 = (size_t)jarg2;
22306   {
22307     try {
22308       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
22309     } catch (std::out_of_range& e) {
22310       {
22311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22312       };
22313     } catch (std::exception& e) {
22314       {
22315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22316       };
22317     } catch (...) {
22318       {
22319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22320       };
22321     }
22322   }
22323   jresult = new Dali::Texture((const Dali::Texture &)result);
22324   return jresult;
22325 }
22326
22327
22328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
22329   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22330   size_t arg2 ;
22331   Dali::Sampler arg3 ;
22332   Dali::Sampler *argp3 ;
22333
22334   arg1 = (Dali::TextureSet *)jarg1;
22335   arg2 = (size_t)jarg2;
22336   argp3 = (Dali::Sampler *)jarg3;
22337   if (!argp3) {
22338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
22339     return ;
22340   }
22341   arg3 = *argp3;
22342   {
22343     try {
22344       (arg1)->SetSampler(arg2,arg3);
22345     } catch (std::out_of_range& e) {
22346       {
22347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22348       };
22349     } catch (std::exception& e) {
22350       {
22351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22352       };
22353     } catch (...) {
22354       {
22355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22356       };
22357     }
22358   }
22359 }
22360
22361
22362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
22363   void * jresult ;
22364   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22365   size_t arg2 ;
22366   Dali::Sampler result;
22367
22368   arg1 = (Dali::TextureSet *)jarg1;
22369   arg2 = (size_t)jarg2;
22370   {
22371     try {
22372       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
22373     } catch (std::out_of_range& e) {
22374       {
22375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22376       };
22377     } catch (std::exception& e) {
22378       {
22379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22380       };
22381     } catch (...) {
22382       {
22383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22384       };
22385     }
22386   }
22387   jresult = new Dali::Sampler((const Dali::Sampler &)result);
22388   return jresult;
22389 }
22390
22391
22392 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
22393   unsigned long jresult ;
22394   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22395   size_t result;
22396
22397   arg1 = (Dali::TextureSet *)jarg1;
22398   {
22399     try {
22400       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
22401     } catch (std::out_of_range& e) {
22402       {
22403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22404       };
22405     } catch (std::exception& e) {
22406       {
22407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22408       };
22409     } catch (...) {
22410       {
22411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22412       };
22413     }
22414   }
22415   jresult = (unsigned long)result;
22416   return jresult;
22417 }
22418
22419
22420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
22421   void * jresult ;
22422   Dali::Property::Map *arg1 = 0 ;
22423   Dali::PropertyBuffer result;
22424
22425   arg1 = (Dali::Property::Map *)jarg1;
22426   if (!arg1) {
22427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
22428     return 0;
22429   }
22430   {
22431     try {
22432       result = Dali::PropertyBuffer::New(*arg1);
22433     } catch (std::out_of_range& e) {
22434       {
22435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22436       };
22437     } catch (std::exception& e) {
22438       {
22439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22440       };
22441     } catch (...) {
22442       {
22443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22444       };
22445     }
22446   }
22447   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22448   return jresult;
22449 }
22450
22451
22452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
22453   void * jresult ;
22454   Dali::PropertyBuffer *result = 0 ;
22455
22456   {
22457     try {
22458       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
22459     } catch (std::out_of_range& e) {
22460       {
22461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22462       };
22463     } catch (std::exception& e) {
22464       {
22465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22466       };
22467     } catch (...) {
22468       {
22469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22470       };
22471     }
22472   }
22473   jresult = (void *)result;
22474   return jresult;
22475 }
22476
22477
22478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
22479   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22480
22481   arg1 = (Dali::PropertyBuffer *)jarg1;
22482   {
22483     try {
22484       delete arg1;
22485     } catch (std::out_of_range& e) {
22486       {
22487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22488       };
22489     } catch (std::exception& e) {
22490       {
22491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22492       };
22493     } catch (...) {
22494       {
22495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22496       };
22497     }
22498   }
22499 }
22500
22501
22502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
22503   void * jresult ;
22504   Dali::PropertyBuffer *arg1 = 0 ;
22505   Dali::PropertyBuffer *result = 0 ;
22506
22507   arg1 = (Dali::PropertyBuffer *)jarg1;
22508   if (!arg1) {
22509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22510     return 0;
22511   }
22512   {
22513     try {
22514       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
22515     } catch (std::out_of_range& e) {
22516       {
22517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22518       };
22519     } catch (std::exception& e) {
22520       {
22521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22522       };
22523     } catch (...) {
22524       {
22525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22526       };
22527     }
22528   }
22529   jresult = (void *)result;
22530   return jresult;
22531 }
22532
22533
22534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
22535   void * jresult ;
22536   Dali::BaseHandle arg1 ;
22537   Dali::BaseHandle *argp1 ;
22538   Dali::PropertyBuffer result;
22539
22540   argp1 = (Dali::BaseHandle *)jarg1;
22541   if (!argp1) {
22542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22543     return 0;
22544   }
22545   arg1 = *argp1;
22546   {
22547     try {
22548       result = Dali::PropertyBuffer::DownCast(arg1);
22549     } catch (std::out_of_range& e) {
22550       {
22551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22552       };
22553     } catch (std::exception& e) {
22554       {
22555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22556       };
22557     } catch (...) {
22558       {
22559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22560       };
22561     }
22562   }
22563   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22564   return jresult;
22565 }
22566
22567
22568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
22569   void * jresult ;
22570   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22571   Dali::PropertyBuffer *arg2 = 0 ;
22572   Dali::PropertyBuffer *result = 0 ;
22573
22574   arg1 = (Dali::PropertyBuffer *)jarg1;
22575   arg2 = (Dali::PropertyBuffer *)jarg2;
22576   if (!arg2) {
22577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22578     return 0;
22579   }
22580   {
22581     try {
22582       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
22583     } catch (std::out_of_range& e) {
22584       {
22585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22586       };
22587     } catch (std::exception& e) {
22588       {
22589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22590       };
22591     } catch (...) {
22592       {
22593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22594       };
22595     }
22596   }
22597   jresult = (void *)result;
22598   return jresult;
22599 }
22600
22601
22602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
22603   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22604   void *arg2 = (void *) 0 ;
22605   std::size_t arg3 ;
22606
22607   arg1 = (Dali::PropertyBuffer *)jarg1;
22608   arg2 = jarg2;
22609   arg3 = (std::size_t)jarg3;
22610   {
22611     try {
22612       (arg1)->SetData((void const *)arg2,arg3);
22613     } catch (std::out_of_range& e) {
22614       {
22615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22616       };
22617     } catch (std::exception& e) {
22618       {
22619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22620       };
22621     } catch (...) {
22622       {
22623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22624       };
22625     }
22626   }
22627 }
22628
22629
22630 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
22631   unsigned long jresult ;
22632   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22633   std::size_t result;
22634
22635   arg1 = (Dali::PropertyBuffer *)jarg1;
22636   {
22637     try {
22638       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
22639     } catch (std::out_of_range& e) {
22640       {
22641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22642       };
22643     } catch (std::exception& e) {
22644       {
22645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22646       };
22647     } catch (...) {
22648       {
22649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22650       };
22651     }
22652   }
22653   jresult = (unsigned long)result;
22654   return jresult;
22655 }
22656
22657
22658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
22659   void * jresult ;
22660   Dali::Geometry result;
22661
22662   {
22663     try {
22664       result = Dali::Geometry::New();
22665     } catch (std::out_of_range& e) {
22666       {
22667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22668       };
22669     } catch (std::exception& e) {
22670       {
22671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22672       };
22673     } catch (...) {
22674       {
22675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22676       };
22677     }
22678   }
22679   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22680   return jresult;
22681 }
22682
22683
22684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
22685   void * jresult ;
22686   Dali::Geometry *result = 0 ;
22687
22688   {
22689     try {
22690       result = (Dali::Geometry *)new Dali::Geometry();
22691     } catch (std::out_of_range& e) {
22692       {
22693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22694       };
22695     } catch (std::exception& e) {
22696       {
22697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22698       };
22699     } catch (...) {
22700       {
22701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22702       };
22703     }
22704   }
22705   jresult = (void *)result;
22706   return jresult;
22707 }
22708
22709
22710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
22711   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22712
22713   arg1 = (Dali::Geometry *)jarg1;
22714   {
22715     try {
22716       delete arg1;
22717     } catch (std::out_of_range& e) {
22718       {
22719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22720       };
22721     } catch (std::exception& e) {
22722       {
22723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22724       };
22725     } catch (...) {
22726       {
22727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22728       };
22729     }
22730   }
22731 }
22732
22733
22734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
22735   void * jresult ;
22736   Dali::Geometry *arg1 = 0 ;
22737   Dali::Geometry *result = 0 ;
22738
22739   arg1 = (Dali::Geometry *)jarg1;
22740   if (!arg1) {
22741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22742     return 0;
22743   }
22744   {
22745     try {
22746       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
22747     } catch (std::out_of_range& e) {
22748       {
22749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22750       };
22751     } catch (std::exception& e) {
22752       {
22753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22754       };
22755     } catch (...) {
22756       {
22757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22758       };
22759     }
22760   }
22761   jresult = (void *)result;
22762   return jresult;
22763 }
22764
22765
22766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
22767   void * jresult ;
22768   Dali::BaseHandle arg1 ;
22769   Dali::BaseHandle *argp1 ;
22770   Dali::Geometry result;
22771
22772   argp1 = (Dali::BaseHandle *)jarg1;
22773   if (!argp1) {
22774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22775     return 0;
22776   }
22777   arg1 = *argp1;
22778   {
22779     try {
22780       result = Dali::Geometry::DownCast(arg1);
22781     } catch (std::out_of_range& e) {
22782       {
22783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22784       };
22785     } catch (std::exception& e) {
22786       {
22787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22788       };
22789     } catch (...) {
22790       {
22791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22792       };
22793     }
22794   }
22795   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22796   return jresult;
22797 }
22798
22799
22800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
22801   void * jresult ;
22802   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22803   Dali::Geometry *arg2 = 0 ;
22804   Dali::Geometry *result = 0 ;
22805
22806   arg1 = (Dali::Geometry *)jarg1;
22807   arg2 = (Dali::Geometry *)jarg2;
22808   if (!arg2) {
22809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22810     return 0;
22811   }
22812   {
22813     try {
22814       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
22815     } catch (std::out_of_range& e) {
22816       {
22817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22818       };
22819     } catch (std::exception& e) {
22820       {
22821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22822       };
22823     } catch (...) {
22824       {
22825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22826       };
22827     }
22828   }
22829   jresult = (void *)result;
22830   return jresult;
22831 }
22832
22833
22834 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
22835   unsigned long jresult ;
22836   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22837   Dali::PropertyBuffer *arg2 = 0 ;
22838   std::size_t result;
22839
22840   arg1 = (Dali::Geometry *)jarg1;
22841   arg2 = (Dali::PropertyBuffer *)jarg2;
22842   if (!arg2) {
22843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
22844     return 0;
22845   }
22846   {
22847     try {
22848       result = (arg1)->AddVertexBuffer(*arg2);
22849     } catch (std::out_of_range& e) {
22850       {
22851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22852       };
22853     } catch (std::exception& e) {
22854       {
22855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22856       };
22857     } catch (...) {
22858       {
22859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22860       };
22861     }
22862   }
22863   jresult = (unsigned long)result;
22864   return jresult;
22865 }
22866
22867
22868 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
22869   unsigned long jresult ;
22870   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22871   std::size_t result;
22872
22873   arg1 = (Dali::Geometry *)jarg1;
22874   {
22875     try {
22876       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
22877     } catch (std::out_of_range& e) {
22878       {
22879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22880       };
22881     } catch (std::exception& e) {
22882       {
22883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22884       };
22885     } catch (...) {
22886       {
22887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22888       };
22889     }
22890   }
22891   jresult = (unsigned long)result;
22892   return jresult;
22893 }
22894
22895
22896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
22897   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22898   std::size_t arg2 ;
22899
22900   arg1 = (Dali::Geometry *)jarg1;
22901   arg2 = (std::size_t)jarg2;
22902   {
22903     try {
22904       (arg1)->RemoveVertexBuffer(arg2);
22905     } catch (std::out_of_range& e) {
22906       {
22907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22908       };
22909     } catch (std::exception& e) {
22910       {
22911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22912       };
22913     } catch (...) {
22914       {
22915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22916       };
22917     }
22918   }
22919 }
22920
22921
22922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
22923   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22924   unsigned short *arg2 = (unsigned short *) 0 ;
22925   size_t arg3 ;
22926
22927   arg1 = (Dali::Geometry *)jarg1;
22928   arg2 = jarg2;
22929   arg3 = (size_t)jarg3;
22930   {
22931     try {
22932       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
22933     } catch (std::out_of_range& e) {
22934       {
22935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22936       };
22937     } catch (std::exception& e) {
22938       {
22939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22940       };
22941     } catch (...) {
22942       {
22943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22944       };
22945     }
22946   }
22947
22948
22949 }
22950
22951
22952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
22953   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22954   Dali::Geometry::Type arg2 ;
22955
22956   arg1 = (Dali::Geometry *)jarg1;
22957   arg2 = (Dali::Geometry::Type)jarg2;
22958   {
22959     try {
22960       (arg1)->SetType(arg2);
22961     } catch (std::out_of_range& e) {
22962       {
22963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22964       };
22965     } catch (std::exception& e) {
22966       {
22967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22968       };
22969     } catch (...) {
22970       {
22971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22972       };
22973     }
22974   }
22975 }
22976
22977
22978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
22979   int jresult ;
22980   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22981   Dali::Geometry::Type result;
22982
22983   arg1 = (Dali::Geometry *)jarg1;
22984   {
22985     try {
22986       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
22987     } catch (std::out_of_range& e) {
22988       {
22989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22990       };
22991     } catch (std::exception& e) {
22992       {
22993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22994       };
22995     } catch (...) {
22996       {
22997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22998       };
22999     }
23000   }
23001   jresult = (int)result;
23002   return jresult;
23003 }
23004
23005
23006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
23007   void * jresult ;
23008   Dali::Shader::Hint *result = 0 ;
23009
23010   {
23011     try {
23012       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
23013     } catch (std::out_of_range& e) {
23014       {
23015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23016       };
23017     } catch (std::exception& e) {
23018       {
23019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23020       };
23021     } catch (...) {
23022       {
23023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23024       };
23025     }
23026   }
23027   jresult = (void *)result;
23028   return jresult;
23029 }
23030
23031
23032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
23033   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
23034
23035   arg1 = (Dali::Shader::Hint *)jarg1;
23036   {
23037     try {
23038       delete arg1;
23039     } catch (std::out_of_range& e) {
23040       {
23041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23042       };
23043     } catch (std::exception& e) {
23044       {
23045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23046       };
23047     } catch (...) {
23048       {
23049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23050       };
23051     }
23052   }
23053 }
23054
23055
23056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
23057   int jresult ;
23058   int result;
23059
23060   result = (int)Dali::Shader::Property::PROGRAM;
23061   jresult = (int)result;
23062   return jresult;
23063 }
23064
23065
23066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
23067   void * jresult ;
23068   Dali::Shader::Property *result = 0 ;
23069
23070   {
23071     try {
23072       result = (Dali::Shader::Property *)new Dali::Shader::Property();
23073     } catch (std::out_of_range& e) {
23074       {
23075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23076       };
23077     } catch (std::exception& e) {
23078       {
23079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23080       };
23081     } catch (...) {
23082       {
23083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23084       };
23085     }
23086   }
23087   jresult = (void *)result;
23088   return jresult;
23089 }
23090
23091
23092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
23093   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
23094
23095   arg1 = (Dali::Shader::Property *)jarg1;
23096   {
23097     try {
23098       delete arg1;
23099     } catch (std::out_of_range& e) {
23100       {
23101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23102       };
23103     } catch (std::exception& e) {
23104       {
23105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23106       };
23107     } catch (...) {
23108       {
23109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23110       };
23111     }
23112   }
23113 }
23114
23115
23116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
23117   void * jresult ;
23118   std::string *arg1 = 0 ;
23119   std::string *arg2 = 0 ;
23120   Dali::Shader::Hint::Value arg3 ;
23121   Dali::Shader result;
23122
23123   if (!jarg1) {
23124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23125     return 0;
23126   }
23127   std::string arg1_str(jarg1);
23128   arg1 = &arg1_str;
23129   if (!jarg2) {
23130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23131     return 0;
23132   }
23133   std::string arg2_str(jarg2);
23134   arg2 = &arg2_str;
23135   arg3 = (Dali::Shader::Hint::Value)jarg3;
23136   {
23137     try {
23138       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
23139     } catch (std::out_of_range& e) {
23140       {
23141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23142       };
23143     } catch (std::exception& e) {
23144       {
23145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23146       };
23147     } catch (...) {
23148       {
23149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23150       };
23151     }
23152   }
23153   jresult = new Dali::Shader((const Dali::Shader &)result);
23154
23155   //argout typemap for const std::string&
23156
23157
23158   //argout typemap for const std::string&
23159
23160   return jresult;
23161 }
23162
23163
23164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
23165   void * jresult ;
23166   std::string *arg1 = 0 ;
23167   std::string *arg2 = 0 ;
23168   Dali::Shader result;
23169
23170   if (!jarg1) {
23171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23172     return 0;
23173   }
23174   std::string arg1_str(jarg1);
23175   arg1 = &arg1_str;
23176   if (!jarg2) {
23177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23178     return 0;
23179   }
23180   std::string arg2_str(jarg2);
23181   arg2 = &arg2_str;
23182   {
23183     try {
23184       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
23185     } catch (std::out_of_range& e) {
23186       {
23187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23188       };
23189     } catch (std::exception& e) {
23190       {
23191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23192       };
23193     } catch (...) {
23194       {
23195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23196       };
23197     }
23198   }
23199   jresult = new Dali::Shader((const Dali::Shader &)result);
23200
23201   //argout typemap for const std::string&
23202
23203
23204   //argout typemap for const std::string&
23205
23206   return jresult;
23207 }
23208
23209
23210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
23211   void * jresult ;
23212   Dali::Shader *result = 0 ;
23213
23214   {
23215     try {
23216       result = (Dali::Shader *)new Dali::Shader();
23217     } catch (std::out_of_range& e) {
23218       {
23219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23220       };
23221     } catch (std::exception& e) {
23222       {
23223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23224       };
23225     } catch (...) {
23226       {
23227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23228       };
23229     }
23230   }
23231   jresult = (void *)result;
23232   return jresult;
23233 }
23234
23235
23236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
23237   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23238
23239   arg1 = (Dali::Shader *)jarg1;
23240   {
23241     try {
23242       delete arg1;
23243     } catch (std::out_of_range& e) {
23244       {
23245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23246       };
23247     } catch (std::exception& e) {
23248       {
23249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23250       };
23251     } catch (...) {
23252       {
23253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23254       };
23255     }
23256   }
23257 }
23258
23259
23260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
23261   void * jresult ;
23262   Dali::Shader *arg1 = 0 ;
23263   Dali::Shader *result = 0 ;
23264
23265   arg1 = (Dali::Shader *)jarg1;
23266   if (!arg1) {
23267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23268     return 0;
23269   }
23270   {
23271     try {
23272       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
23273     } catch (std::out_of_range& e) {
23274       {
23275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23276       };
23277     } catch (std::exception& e) {
23278       {
23279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23280       };
23281     } catch (...) {
23282       {
23283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23284       };
23285     }
23286   }
23287   jresult = (void *)result;
23288   return jresult;
23289 }
23290
23291
23292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
23293   void * jresult ;
23294   Dali::BaseHandle arg1 ;
23295   Dali::BaseHandle *argp1 ;
23296   Dali::Shader result;
23297
23298   argp1 = (Dali::BaseHandle *)jarg1;
23299   if (!argp1) {
23300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23301     return 0;
23302   }
23303   arg1 = *argp1;
23304   {
23305     try {
23306       result = Dali::Shader::DownCast(arg1);
23307     } catch (std::out_of_range& e) {
23308       {
23309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23310       };
23311     } catch (std::exception& e) {
23312       {
23313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23314       };
23315     } catch (...) {
23316       {
23317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23318       };
23319     }
23320   }
23321   jresult = new Dali::Shader((const Dali::Shader &)result);
23322   return jresult;
23323 }
23324
23325
23326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
23327   void * jresult ;
23328   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23329   Dali::Shader *arg2 = 0 ;
23330   Dali::Shader *result = 0 ;
23331
23332   arg1 = (Dali::Shader *)jarg1;
23333   arg2 = (Dali::Shader *)jarg2;
23334   if (!arg2) {
23335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23336     return 0;
23337   }
23338   {
23339     try {
23340       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
23341     } catch (std::out_of_range& e) {
23342       {
23343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23344       };
23345     } catch (std::exception& e) {
23346       {
23347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23348       };
23349     } catch (...) {
23350       {
23351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23352       };
23353     }
23354   }
23355   jresult = (void *)result;
23356   return jresult;
23357 }
23358
23359
23360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
23361   int jresult ;
23362   int result;
23363
23364   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
23365   jresult = (int)result;
23366   return jresult;
23367 }
23368
23369
23370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
23371   int jresult ;
23372   int result;
23373
23374   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
23375   jresult = (int)result;
23376   return jresult;
23377 }
23378
23379
23380 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
23381   int jresult ;
23382   int result;
23383
23384   result = (int)Dali::Renderer::Property::BLEND_MODE;
23385   jresult = (int)result;
23386   return jresult;
23387 }
23388
23389
23390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
23391   int jresult ;
23392   int result;
23393
23394   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
23395   jresult = (int)result;
23396   return jresult;
23397 }
23398
23399
23400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
23401   int jresult ;
23402   int result;
23403
23404   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
23405   jresult = (int)result;
23406   return jresult;
23407 }
23408
23409
23410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
23411   int jresult ;
23412   int result;
23413
23414   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
23415   jresult = (int)result;
23416   return jresult;
23417 }
23418
23419
23420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
23421   int jresult ;
23422   int result;
23423
23424   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
23425   jresult = (int)result;
23426   return jresult;
23427 }
23428
23429
23430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
23431   int jresult ;
23432   int result;
23433
23434   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
23435   jresult = (int)result;
23436   return jresult;
23437 }
23438
23439
23440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
23441   int jresult ;
23442   int result;
23443
23444   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
23445   jresult = (int)result;
23446   return jresult;
23447 }
23448
23449
23450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
23451   int jresult ;
23452   int result;
23453
23454   result = (int)Dali::Renderer::Property::BLEND_COLOR;
23455   jresult = (int)result;
23456   return jresult;
23457 }
23458
23459
23460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
23461   int jresult ;
23462   int result;
23463
23464   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
23465   jresult = (int)result;
23466   return jresult;
23467 }
23468
23469
23470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
23471   int jresult ;
23472   int result;
23473
23474   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
23475   jresult = (int)result;
23476   return jresult;
23477 }
23478
23479
23480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
23481   int jresult ;
23482   int result;
23483
23484   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
23485   jresult = (int)result;
23486   return jresult;
23487 }
23488
23489
23490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
23491   int jresult ;
23492   int result;
23493
23494   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
23495   jresult = (int)result;
23496   return jresult;
23497 }
23498
23499
23500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
23501   int jresult ;
23502   int result;
23503
23504   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
23505   jresult = (int)result;
23506   return jresult;
23507 }
23508
23509
23510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
23511   int jresult ;
23512   int result;
23513
23514   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
23515   jresult = (int)result;
23516   return jresult;
23517 }
23518
23519
23520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
23521   int jresult ;
23522   int result;
23523
23524   result = (int)Dali::Renderer::Property::RENDER_MODE;
23525   jresult = (int)result;
23526   return jresult;
23527 }
23528
23529
23530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
23531   int jresult ;
23532   int result;
23533
23534   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
23535   jresult = (int)result;
23536   return jresult;
23537 }
23538
23539
23540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
23541   int jresult ;
23542   int result;
23543
23544   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
23545   jresult = (int)result;
23546   return jresult;
23547 }
23548
23549
23550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
23551   int jresult ;
23552   int result;
23553
23554   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
23555   jresult = (int)result;
23556   return jresult;
23557 }
23558
23559
23560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
23561   int jresult ;
23562   int result;
23563
23564   result = (int)Dali::Renderer::Property::STENCIL_MASK;
23565   jresult = (int)result;
23566   return jresult;
23567 }
23568
23569
23570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
23571   int jresult ;
23572   int result;
23573
23574   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
23575   jresult = (int)result;
23576   return jresult;
23577 }
23578
23579
23580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
23581   int jresult ;
23582   int result;
23583
23584   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
23585   jresult = (int)result;
23586   return jresult;
23587 }
23588
23589
23590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
23591   int jresult ;
23592   int result;
23593
23594   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
23595   jresult = (int)result;
23596   return jresult;
23597 }
23598
23599
23600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
23601   void * jresult ;
23602   Dali::Renderer::Property *result = 0 ;
23603
23604   {
23605     try {
23606       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
23607     } catch (std::out_of_range& e) {
23608       {
23609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23610       };
23611     } catch (std::exception& e) {
23612       {
23613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23614       };
23615     } catch (...) {
23616       {
23617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23618       };
23619     }
23620   }
23621   jresult = (void *)result;
23622   return jresult;
23623 }
23624
23625
23626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
23627   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
23628
23629   arg1 = (Dali::Renderer::Property *)jarg1;
23630   {
23631     try {
23632       delete arg1;
23633     } catch (std::out_of_range& e) {
23634       {
23635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23636       };
23637     } catch (std::exception& e) {
23638       {
23639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23640       };
23641     } catch (...) {
23642       {
23643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23644       };
23645     }
23646   }
23647 }
23648
23649
23650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
23651   void * jresult ;
23652   Dali::Geometry *arg1 = 0 ;
23653   Dali::Shader *arg2 = 0 ;
23654   Dali::Renderer result;
23655
23656   arg1 = (Dali::Geometry *)jarg1;
23657   if (!arg1) {
23658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23659     return 0;
23660   }
23661   arg2 = (Dali::Shader *)jarg2;
23662   if (!arg2) {
23663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23664     return 0;
23665   }
23666   {
23667     try {
23668       result = Dali::Renderer::New(*arg1,*arg2);
23669     } catch (std::out_of_range& e) {
23670       {
23671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23672       };
23673     } catch (std::exception& e) {
23674       {
23675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23676       };
23677     } catch (...) {
23678       {
23679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23680       };
23681     }
23682   }
23683   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23684   return jresult;
23685 }
23686
23687
23688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
23689   void * jresult ;
23690   Dali::Renderer *result = 0 ;
23691
23692   {
23693     try {
23694       result = (Dali::Renderer *)new Dali::Renderer();
23695     } catch (std::out_of_range& e) {
23696       {
23697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23698       };
23699     } catch (std::exception& e) {
23700       {
23701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23702       };
23703     } catch (...) {
23704       {
23705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23706       };
23707     }
23708   }
23709   jresult = (void *)result;
23710   return jresult;
23711 }
23712
23713
23714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
23715   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23716
23717   arg1 = (Dali::Renderer *)jarg1;
23718   {
23719     try {
23720       delete arg1;
23721     } catch (std::out_of_range& e) {
23722       {
23723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23724       };
23725     } catch (std::exception& e) {
23726       {
23727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23728       };
23729     } catch (...) {
23730       {
23731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23732       };
23733     }
23734   }
23735 }
23736
23737
23738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
23739   void * jresult ;
23740   Dali::Renderer *arg1 = 0 ;
23741   Dali::Renderer *result = 0 ;
23742
23743   arg1 = (Dali::Renderer *)jarg1;
23744   if (!arg1) {
23745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23746     return 0;
23747   }
23748   {
23749     try {
23750       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
23751     } catch (std::out_of_range& e) {
23752       {
23753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23754       };
23755     } catch (std::exception& e) {
23756       {
23757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23758       };
23759     } catch (...) {
23760       {
23761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23762       };
23763     }
23764   }
23765   jresult = (void *)result;
23766   return jresult;
23767 }
23768
23769
23770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
23771   void * jresult ;
23772   Dali::BaseHandle arg1 ;
23773   Dali::BaseHandle *argp1 ;
23774   Dali::Renderer result;
23775
23776   argp1 = (Dali::BaseHandle *)jarg1;
23777   if (!argp1) {
23778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23779     return 0;
23780   }
23781   arg1 = *argp1;
23782   {
23783     try {
23784       result = Dali::Renderer::DownCast(arg1);
23785     } catch (std::out_of_range& e) {
23786       {
23787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23788       };
23789     } catch (std::exception& e) {
23790       {
23791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23792       };
23793     } catch (...) {
23794       {
23795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23796       };
23797     }
23798   }
23799   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23800   return jresult;
23801 }
23802
23803
23804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
23805   void * jresult ;
23806   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23807   Dali::Renderer *arg2 = 0 ;
23808   Dali::Renderer *result = 0 ;
23809
23810   arg1 = (Dali::Renderer *)jarg1;
23811   arg2 = (Dali::Renderer *)jarg2;
23812   if (!arg2) {
23813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23814     return 0;
23815   }
23816   {
23817     try {
23818       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
23819     } catch (std::out_of_range& e) {
23820       {
23821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23822       };
23823     } catch (std::exception& e) {
23824       {
23825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23826       };
23827     } catch (...) {
23828       {
23829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23830       };
23831     }
23832   }
23833   jresult = (void *)result;
23834   return jresult;
23835 }
23836
23837
23838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
23839   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23840   Dali::Geometry *arg2 = 0 ;
23841
23842   arg1 = (Dali::Renderer *)jarg1;
23843   arg2 = (Dali::Geometry *)jarg2;
23844   if (!arg2) {
23845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23846     return ;
23847   }
23848   {
23849     try {
23850       (arg1)->SetGeometry(*arg2);
23851     } catch (std::out_of_range& e) {
23852       {
23853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23854       };
23855     } catch (std::exception& e) {
23856       {
23857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23858       };
23859     } catch (...) {
23860       {
23861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23862       };
23863     }
23864   }
23865 }
23866
23867
23868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
23869   void * jresult ;
23870   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23871   Dali::Geometry result;
23872
23873   arg1 = (Dali::Renderer *)jarg1;
23874   {
23875     try {
23876       result = ((Dali::Renderer const *)arg1)->GetGeometry();
23877     } catch (std::out_of_range& e) {
23878       {
23879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23880       };
23881     } catch (std::exception& e) {
23882       {
23883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23884       };
23885     } catch (...) {
23886       {
23887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23888       };
23889     }
23890   }
23891   jresult = new Dali::Geometry((const Dali::Geometry &)result);
23892   return jresult;
23893 }
23894
23895
23896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
23897   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23898   int arg2 ;
23899   int arg3 ;
23900
23901   arg1 = (Dali::Renderer *)jarg1;
23902   arg2 = (int)jarg2;
23903   arg3 = (int)jarg3;
23904   {
23905     try {
23906       (arg1)->SetIndexRange(arg2,arg3);
23907     } catch (std::out_of_range& e) {
23908       {
23909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23910       };
23911     } catch (std::exception& e) {
23912       {
23913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23914       };
23915     } catch (...) {
23916       {
23917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23918       };
23919     }
23920   }
23921 }
23922
23923
23924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
23925   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23926   Dali::TextureSet *arg2 = 0 ;
23927
23928   arg1 = (Dali::Renderer *)jarg1;
23929   arg2 = (Dali::TextureSet *)jarg2;
23930   if (!arg2) {
23931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
23932     return ;
23933   }
23934   {
23935     try {
23936       (arg1)->SetTextures(*arg2);
23937     } catch (std::out_of_range& e) {
23938       {
23939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23940       };
23941     } catch (std::exception& e) {
23942       {
23943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23944       };
23945     } catch (...) {
23946       {
23947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23948       };
23949     }
23950   }
23951 }
23952
23953
23954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
23955   void * jresult ;
23956   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23957   Dali::TextureSet result;
23958
23959   arg1 = (Dali::Renderer *)jarg1;
23960   {
23961     try {
23962       result = ((Dali::Renderer const *)arg1)->GetTextures();
23963     } catch (std::out_of_range& e) {
23964       {
23965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23966       };
23967     } catch (std::exception& e) {
23968       {
23969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23970       };
23971     } catch (...) {
23972       {
23973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23974       };
23975     }
23976   }
23977   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
23978   return jresult;
23979 }
23980
23981
23982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
23983   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23984   Dali::Shader *arg2 = 0 ;
23985
23986   arg1 = (Dali::Renderer *)jarg1;
23987   arg2 = (Dali::Shader *)jarg2;
23988   if (!arg2) {
23989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23990     return ;
23991   }
23992   {
23993     try {
23994       (arg1)->SetShader(*arg2);
23995     } catch (std::out_of_range& e) {
23996       {
23997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23998       };
23999     } catch (std::exception& e) {
24000       {
24001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24002       };
24003     } catch (...) {
24004       {
24005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24006       };
24007     }
24008   }
24009 }
24010
24011
24012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
24013   void * jresult ;
24014   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
24015   Dali::Shader result;
24016
24017   arg1 = (Dali::Renderer *)jarg1;
24018   {
24019     try {
24020       result = ((Dali::Renderer const *)arg1)->GetShader();
24021     } catch (std::out_of_range& e) {
24022       {
24023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24024       };
24025     } catch (std::exception& e) {
24026       {
24027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24028       };
24029     } catch (...) {
24030       {
24031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24032       };
24033     }
24034   }
24035   jresult = new Dali::Shader((const Dali::Shader &)result);
24036   return jresult;
24037 }
24038
24039
24040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
24041   void * jresult ;
24042   Dali::FrameBuffer::Attachment *result = 0 ;
24043
24044   {
24045     try {
24046       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
24047     } catch (std::out_of_range& e) {
24048       {
24049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24050       };
24051     } catch (std::exception& e) {
24052       {
24053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24054       };
24055     } catch (...) {
24056       {
24057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24058       };
24059     }
24060   }
24061   jresult = (void *)result;
24062   return jresult;
24063 }
24064
24065
24066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
24067   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
24068
24069   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
24070   {
24071     try {
24072       delete arg1;
24073     } catch (std::out_of_range& e) {
24074       {
24075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24076       };
24077     } catch (std::exception& e) {
24078       {
24079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24080       };
24081     } catch (...) {
24082       {
24083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24084       };
24085     }
24086   }
24087 }
24088
24089
24090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
24091   void * jresult ;
24092   unsigned int arg1 ;
24093   unsigned int arg2 ;
24094   unsigned int arg3 ;
24095   Dali::FrameBuffer result;
24096
24097   arg1 = (unsigned int)jarg1;
24098   arg2 = (unsigned int)jarg2;
24099   arg3 = (unsigned int)jarg3;
24100   {
24101     try {
24102       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
24103     } catch (std::out_of_range& e) {
24104       {
24105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24106       };
24107     } catch (std::exception& e) {
24108       {
24109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24110       };
24111     } catch (...) {
24112       {
24113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24114       };
24115     }
24116   }
24117   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24118   return jresult;
24119 }
24120
24121
24122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
24123   void * jresult ;
24124   Dali::FrameBuffer *result = 0 ;
24125
24126   {
24127     try {
24128       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
24129     } catch (std::out_of_range& e) {
24130       {
24131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24132       };
24133     } catch (std::exception& e) {
24134       {
24135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24136       };
24137     } catch (...) {
24138       {
24139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24140       };
24141     }
24142   }
24143   jresult = (void *)result;
24144   return jresult;
24145 }
24146
24147
24148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
24149   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24150
24151   arg1 = (Dali::FrameBuffer *)jarg1;
24152   {
24153     try {
24154       delete arg1;
24155     } catch (std::out_of_range& e) {
24156       {
24157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24158       };
24159     } catch (std::exception& e) {
24160       {
24161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24162       };
24163     } catch (...) {
24164       {
24165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24166       };
24167     }
24168   }
24169 }
24170
24171
24172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
24173   void * jresult ;
24174   Dali::FrameBuffer *arg1 = 0 ;
24175   Dali::FrameBuffer *result = 0 ;
24176
24177   arg1 = (Dali::FrameBuffer *)jarg1;
24178   if (!arg1) {
24179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24180     return 0;
24181   }
24182   {
24183     try {
24184       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
24185     } catch (std::out_of_range& e) {
24186       {
24187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24188       };
24189     } catch (std::exception& e) {
24190       {
24191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24192       };
24193     } catch (...) {
24194       {
24195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24196       };
24197     }
24198   }
24199   jresult = (void *)result;
24200   return jresult;
24201 }
24202
24203
24204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
24205   void * jresult ;
24206   Dali::BaseHandle arg1 ;
24207   Dali::BaseHandle *argp1 ;
24208   Dali::FrameBuffer result;
24209
24210   argp1 = (Dali::BaseHandle *)jarg1;
24211   if (!argp1) {
24212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24213     return 0;
24214   }
24215   arg1 = *argp1;
24216   {
24217     try {
24218       result = Dali::FrameBuffer::DownCast(arg1);
24219     } catch (std::out_of_range& e) {
24220       {
24221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24222       };
24223     } catch (std::exception& e) {
24224       {
24225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24226       };
24227     } catch (...) {
24228       {
24229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24230       };
24231     }
24232   }
24233   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24234   return jresult;
24235 }
24236
24237
24238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
24239   void * jresult ;
24240   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24241   Dali::FrameBuffer *arg2 = 0 ;
24242   Dali::FrameBuffer *result = 0 ;
24243
24244   arg1 = (Dali::FrameBuffer *)jarg1;
24245   arg2 = (Dali::FrameBuffer *)jarg2;
24246   if (!arg2) {
24247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24248     return 0;
24249   }
24250   {
24251     try {
24252       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
24253     } catch (std::out_of_range& e) {
24254       {
24255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24256       };
24257     } catch (std::exception& e) {
24258       {
24259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24260       };
24261     } catch (...) {
24262       {
24263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24264       };
24265     }
24266   }
24267   jresult = (void *)result;
24268   return jresult;
24269 }
24270
24271
24272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
24273   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24274   Dali::Texture *arg2 = 0 ;
24275
24276   arg1 = (Dali::FrameBuffer *)jarg1;
24277   arg2 = (Dali::Texture *)jarg2;
24278   if (!arg2) {
24279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24280     return ;
24281   }
24282   {
24283     try {
24284       (arg1)->AttachColorTexture(*arg2);
24285     } catch (std::out_of_range& e) {
24286       {
24287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24288       };
24289     } catch (std::exception& e) {
24290       {
24291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24292       };
24293     } catch (...) {
24294       {
24295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24296       };
24297     }
24298   }
24299 }
24300
24301
24302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
24303   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24304   Dali::Texture *arg2 = 0 ;
24305   unsigned int arg3 ;
24306   unsigned int arg4 ;
24307
24308   arg1 = (Dali::FrameBuffer *)jarg1;
24309   arg2 = (Dali::Texture *)jarg2;
24310   if (!arg2) {
24311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24312     return ;
24313   }
24314   arg3 = (unsigned int)jarg3;
24315   arg4 = (unsigned int)jarg4;
24316   {
24317     try {
24318       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
24319     } catch (std::out_of_range& e) {
24320       {
24321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24322       };
24323     } catch (std::exception& e) {
24324       {
24325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24326       };
24327     } catch (...) {
24328       {
24329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24330       };
24331     }
24332   }
24333 }
24334
24335
24336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
24337   void * jresult ;
24338   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24339   Dali::Texture result;
24340
24341   arg1 = (Dali::FrameBuffer *)jarg1;
24342   {
24343     try {
24344       result = (arg1)->GetColorTexture();
24345     } catch (std::out_of_range& e) {
24346       {
24347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24348       };
24349     } catch (std::exception& e) {
24350       {
24351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24352       };
24353     } catch (...) {
24354       {
24355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24356       };
24357     }
24358   }
24359   jresult = new Dali::Texture((const Dali::Texture &)result);
24360   return jresult;
24361 }
24362
24363
24364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
24365   void * jresult ;
24366   Dali::RenderTaskList *result = 0 ;
24367
24368   {
24369     try {
24370       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
24371     } catch (std::out_of_range& e) {
24372       {
24373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24374       };
24375     } catch (std::exception& e) {
24376       {
24377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24378       };
24379     } catch (...) {
24380       {
24381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24382       };
24383     }
24384   }
24385   jresult = (void *)result;
24386   return jresult;
24387 }
24388
24389
24390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
24391   void * jresult ;
24392   Dali::BaseHandle arg1 ;
24393   Dali::BaseHandle *argp1 ;
24394   Dali::RenderTaskList result;
24395
24396   argp1 = (Dali::BaseHandle *)jarg1;
24397   if (!argp1) {
24398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24399     return 0;
24400   }
24401   arg1 = *argp1;
24402   {
24403     try {
24404       result = Dali::RenderTaskList::DownCast(arg1);
24405     } catch (std::out_of_range& e) {
24406       {
24407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24408       };
24409     } catch (std::exception& e) {
24410       {
24411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24412       };
24413     } catch (...) {
24414       {
24415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24416       };
24417     }
24418   }
24419   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
24420   return jresult;
24421 }
24422
24423
24424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
24425   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24426
24427   arg1 = (Dali::RenderTaskList *)jarg1;
24428   {
24429     try {
24430       delete arg1;
24431     } catch (std::out_of_range& e) {
24432       {
24433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24434       };
24435     } catch (std::exception& e) {
24436       {
24437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24438       };
24439     } catch (...) {
24440       {
24441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24442       };
24443     }
24444   }
24445 }
24446
24447
24448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
24449   void * jresult ;
24450   Dali::RenderTaskList *arg1 = 0 ;
24451   Dali::RenderTaskList *result = 0 ;
24452
24453   arg1 = (Dali::RenderTaskList *)jarg1;
24454   if (!arg1) {
24455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24456     return 0;
24457   }
24458   {
24459     try {
24460       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
24461     } catch (std::out_of_range& e) {
24462       {
24463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24464       };
24465     } catch (std::exception& e) {
24466       {
24467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24468       };
24469     } catch (...) {
24470       {
24471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24472       };
24473     }
24474   }
24475   jresult = (void *)result;
24476   return jresult;
24477 }
24478
24479
24480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
24481   void * jresult ;
24482   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24483   Dali::RenderTaskList *arg2 = 0 ;
24484   Dali::RenderTaskList *result = 0 ;
24485
24486   arg1 = (Dali::RenderTaskList *)jarg1;
24487   arg2 = (Dali::RenderTaskList *)jarg2;
24488   if (!arg2) {
24489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24490     return 0;
24491   }
24492   {
24493     try {
24494       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
24495     } catch (std::out_of_range& e) {
24496       {
24497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24498       };
24499     } catch (std::exception& e) {
24500       {
24501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24502       };
24503     } catch (...) {
24504       {
24505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24506       };
24507     }
24508   }
24509   jresult = (void *)result;
24510   return jresult;
24511 }
24512
24513
24514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
24515   void * jresult ;
24516   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24517   Dali::RenderTask result;
24518
24519   arg1 = (Dali::RenderTaskList *)jarg1;
24520   {
24521     try {
24522       result = (arg1)->CreateTask();
24523     } catch (std::out_of_range& e) {
24524       {
24525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24526       };
24527     } catch (std::exception& e) {
24528       {
24529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24530       };
24531     } catch (...) {
24532       {
24533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24534       };
24535     }
24536   }
24537   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24538   return jresult;
24539 }
24540
24541
24542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
24543   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24544   Dali::RenderTask arg2 ;
24545   Dali::RenderTask *argp2 ;
24546
24547   arg1 = (Dali::RenderTaskList *)jarg1;
24548   argp2 = (Dali::RenderTask *)jarg2;
24549   if (!argp2) {
24550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
24551     return ;
24552   }
24553   arg2 = *argp2;
24554   {
24555     try {
24556       (arg1)->RemoveTask(arg2);
24557     } catch (std::out_of_range& e) {
24558       {
24559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24560       };
24561     } catch (std::exception& e) {
24562       {
24563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24564       };
24565     } catch (...) {
24566       {
24567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24568       };
24569     }
24570   }
24571 }
24572
24573
24574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
24575   unsigned int jresult ;
24576   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24577   unsigned int result;
24578
24579   arg1 = (Dali::RenderTaskList *)jarg1;
24580   {
24581     try {
24582       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
24583     } catch (std::out_of_range& e) {
24584       {
24585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24586       };
24587     } catch (std::exception& e) {
24588       {
24589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24590       };
24591     } catch (...) {
24592       {
24593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24594       };
24595     }
24596   }
24597   jresult = result;
24598   return jresult;
24599 }
24600
24601
24602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
24603   void * jresult ;
24604   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24605   unsigned int arg2 ;
24606   Dali::RenderTask result;
24607
24608   arg1 = (Dali::RenderTaskList *)jarg1;
24609   arg2 = (unsigned int)jarg2;
24610   {
24611     try {
24612       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
24613     } catch (std::out_of_range& e) {
24614       {
24615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24616       };
24617     } catch (std::exception& e) {
24618       {
24619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24620       };
24621     } catch (...) {
24622       {
24623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24624       };
24625     }
24626   }
24627   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24628   return jresult;
24629 }
24630
24631
24632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
24633   int jresult ;
24634   int result;
24635
24636   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
24637   jresult = (int)result;
24638   return jresult;
24639 }
24640
24641
24642 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
24643   int jresult ;
24644   int result;
24645
24646   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
24647   jresult = (int)result;
24648   return jresult;
24649 }
24650
24651
24652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
24653   int jresult ;
24654   int result;
24655
24656   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
24657   jresult = (int)result;
24658   return jresult;
24659 }
24660
24661
24662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
24663   int jresult ;
24664   int result;
24665
24666   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
24667   jresult = (int)result;
24668   return jresult;
24669 }
24670
24671
24672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
24673   void * jresult ;
24674   Dali::RenderTask::Property *result = 0 ;
24675
24676   {
24677     try {
24678       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
24679     } catch (std::out_of_range& e) {
24680       {
24681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24682       };
24683     } catch (std::exception& e) {
24684       {
24685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24686       };
24687     } catch (...) {
24688       {
24689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24690       };
24691     }
24692   }
24693   jresult = (void *)result;
24694   return jresult;
24695 }
24696
24697
24698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
24699   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
24700
24701   arg1 = (Dali::RenderTask::Property *)jarg1;
24702   {
24703     try {
24704       delete arg1;
24705     } catch (std::out_of_range& e) {
24706       {
24707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24708       };
24709     } catch (std::exception& e) {
24710       {
24711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24712       };
24713     } catch (...) {
24714       {
24715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24716       };
24717     }
24718   }
24719 }
24720
24721
24722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
24723   void * jresult ;
24724   bool (*result)(Dali::Vector2 &) = 0 ;
24725
24726   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
24727   jresult = (void *)result;
24728   return jresult;
24729 }
24730
24731
24732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
24733   void * jresult ;
24734   bool (*result)(Dali::Vector2 &) = 0 ;
24735
24736   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
24737   jresult = (void *)result;
24738   return jresult;
24739 }
24740
24741
24742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
24743   unsigned int jresult ;
24744   bool result;
24745
24746   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
24747   jresult = result;
24748   return jresult;
24749 }
24750
24751
24752 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
24753   unsigned int jresult ;
24754   bool result;
24755
24756   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
24757   jresult = result;
24758   return jresult;
24759 }
24760
24761
24762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
24763   void * jresult ;
24764   Dali::Vector4 *result = 0 ;
24765
24766   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
24767   jresult = (void *)result;
24768   return jresult;
24769 }
24770
24771
24772 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
24773   unsigned int jresult ;
24774   bool result;
24775
24776   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
24777   jresult = result;
24778   return jresult;
24779 }
24780
24781
24782 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
24783   unsigned int jresult ;
24784   bool result;
24785
24786   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
24787   jresult = result;
24788   return jresult;
24789 }
24790
24791
24792 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
24793   unsigned int jresult ;
24794   unsigned int result;
24795
24796   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
24797   jresult = result;
24798   return jresult;
24799 }
24800
24801
24802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
24803   void * jresult ;
24804   Dali::RenderTask *result = 0 ;
24805
24806   {
24807     try {
24808       result = (Dali::RenderTask *)new Dali::RenderTask();
24809     } catch (std::out_of_range& e) {
24810       {
24811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24812       };
24813     } catch (std::exception& e) {
24814       {
24815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24816       };
24817     } catch (...) {
24818       {
24819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24820       };
24821     }
24822   }
24823   jresult = (void *)result;
24824   return jresult;
24825 }
24826
24827
24828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
24829   void * jresult ;
24830   Dali::BaseHandle arg1 ;
24831   Dali::BaseHandle *argp1 ;
24832   Dali::RenderTask result;
24833
24834   argp1 = (Dali::BaseHandle *)jarg1;
24835   if (!argp1) {
24836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24837     return 0;
24838   }
24839   arg1 = *argp1;
24840   {
24841     try {
24842       result = Dali::RenderTask::DownCast(arg1);
24843     } catch (std::out_of_range& e) {
24844       {
24845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24846       };
24847     } catch (std::exception& e) {
24848       {
24849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24850       };
24851     } catch (...) {
24852       {
24853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24854       };
24855     }
24856   }
24857   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24858   return jresult;
24859 }
24860
24861
24862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
24863   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24864
24865   arg1 = (Dali::RenderTask *)jarg1;
24866   {
24867     try {
24868       delete arg1;
24869     } catch (std::out_of_range& e) {
24870       {
24871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24872       };
24873     } catch (std::exception& e) {
24874       {
24875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24876       };
24877     } catch (...) {
24878       {
24879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24880       };
24881     }
24882   }
24883 }
24884
24885
24886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
24887   void * jresult ;
24888   Dali::RenderTask *arg1 = 0 ;
24889   Dali::RenderTask *result = 0 ;
24890
24891   arg1 = (Dali::RenderTask *)jarg1;
24892   if (!arg1) {
24893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24894     return 0;
24895   }
24896   {
24897     try {
24898       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
24899     } catch (std::out_of_range& e) {
24900       {
24901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24902       };
24903     } catch (std::exception& e) {
24904       {
24905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24906       };
24907     } catch (...) {
24908       {
24909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24910       };
24911     }
24912   }
24913   jresult = (void *)result;
24914   return jresult;
24915 }
24916
24917
24918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
24919   void * jresult ;
24920   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24921   Dali::RenderTask *arg2 = 0 ;
24922   Dali::RenderTask *result = 0 ;
24923
24924   arg1 = (Dali::RenderTask *)jarg1;
24925   arg2 = (Dali::RenderTask *)jarg2;
24926   if (!arg2) {
24927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24928     return 0;
24929   }
24930   {
24931     try {
24932       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
24933     } catch (std::out_of_range& e) {
24934       {
24935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24936       };
24937     } catch (std::exception& e) {
24938       {
24939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24940       };
24941     } catch (...) {
24942       {
24943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24944       };
24945     }
24946   }
24947   jresult = (void *)result;
24948   return jresult;
24949 }
24950
24951
24952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
24953   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24954   Dali::Actor arg2 ;
24955   Dali::Actor *argp2 ;
24956
24957   arg1 = (Dali::RenderTask *)jarg1;
24958   argp2 = (Dali::Actor *)jarg2;
24959   if (!argp2) {
24960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24961     return ;
24962   }
24963   arg2 = *argp2;
24964   {
24965     try {
24966       (arg1)->SetSourceActor(arg2);
24967     } catch (std::out_of_range& e) {
24968       {
24969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24970       };
24971     } catch (std::exception& e) {
24972       {
24973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24974       };
24975     } catch (...) {
24976       {
24977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24978       };
24979     }
24980   }
24981 }
24982
24983
24984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
24985   void * jresult ;
24986   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24987   Dali::Actor result;
24988
24989   arg1 = (Dali::RenderTask *)jarg1;
24990   {
24991     try {
24992       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
24993     } catch (std::out_of_range& e) {
24994       {
24995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24996       };
24997     } catch (std::exception& e) {
24998       {
24999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25000       };
25001     } catch (...) {
25002       {
25003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25004       };
25005     }
25006   }
25007   jresult = new Dali::Actor((const Dali::Actor &)result);
25008   return jresult;
25009 }
25010
25011
25012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
25013   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25014   bool arg2 ;
25015
25016   arg1 = (Dali::RenderTask *)jarg1;
25017   arg2 = jarg2 ? true : false;
25018   {
25019     try {
25020       (arg1)->SetExclusive(arg2);
25021     } catch (std::out_of_range& e) {
25022       {
25023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25024       };
25025     } catch (std::exception& e) {
25026       {
25027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25028       };
25029     } catch (...) {
25030       {
25031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25032       };
25033     }
25034   }
25035 }
25036
25037
25038 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
25039   unsigned int jresult ;
25040   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25041   bool result;
25042
25043   arg1 = (Dali::RenderTask *)jarg1;
25044   {
25045     try {
25046       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
25047     } catch (std::out_of_range& e) {
25048       {
25049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25050       };
25051     } catch (std::exception& e) {
25052       {
25053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25054       };
25055     } catch (...) {
25056       {
25057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25058       };
25059     }
25060   }
25061   jresult = result;
25062   return jresult;
25063 }
25064
25065
25066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
25067   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25068   bool arg2 ;
25069
25070   arg1 = (Dali::RenderTask *)jarg1;
25071   arg2 = jarg2 ? true : false;
25072   {
25073     try {
25074       (arg1)->SetInputEnabled(arg2);
25075     } catch (std::out_of_range& e) {
25076       {
25077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25078       };
25079     } catch (std::exception& e) {
25080       {
25081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25082       };
25083     } catch (...) {
25084       {
25085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25086       };
25087     }
25088   }
25089 }
25090
25091
25092 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
25093   unsigned int jresult ;
25094   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25095   bool result;
25096
25097   arg1 = (Dali::RenderTask *)jarg1;
25098   {
25099     try {
25100       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
25101     } catch (std::out_of_range& e) {
25102       {
25103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25104       };
25105     } catch (std::exception& e) {
25106       {
25107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25108       };
25109     } catch (...) {
25110       {
25111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25112       };
25113     }
25114   }
25115   jresult = result;
25116   return jresult;
25117 }
25118
25119
25120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
25121   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25122   Dali::CameraActor arg2 ;
25123   Dali::CameraActor *argp2 ;
25124
25125   arg1 = (Dali::RenderTask *)jarg1;
25126   argp2 = (Dali::CameraActor *)jarg2;
25127   if (!argp2) {
25128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
25129     return ;
25130   }
25131   arg2 = *argp2;
25132   {
25133     try {
25134       (arg1)->SetCameraActor(arg2);
25135     } catch (std::out_of_range& e) {
25136       {
25137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25138       };
25139     } catch (std::exception& e) {
25140       {
25141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25142       };
25143     } catch (...) {
25144       {
25145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25146       };
25147     }
25148   }
25149 }
25150
25151
25152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
25153   void * jresult ;
25154   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25155   Dali::CameraActor result;
25156
25157   arg1 = (Dali::RenderTask *)jarg1;
25158   {
25159     try {
25160       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
25161     } catch (std::out_of_range& e) {
25162       {
25163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25164       };
25165     } catch (std::exception& e) {
25166       {
25167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25168       };
25169     } catch (...) {
25170       {
25171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25172       };
25173     }
25174   }
25175   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
25176   return jresult;
25177 }
25178
25179
25180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
25181   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25182   Dali::FrameBufferImage arg2 ;
25183   Dali::FrameBufferImage *argp2 ;
25184
25185   arg1 = (Dali::RenderTask *)jarg1;
25186   argp2 = (Dali::FrameBufferImage *)jarg2;
25187   if (!argp2) {
25188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
25189     return ;
25190   }
25191   arg2 = *argp2;
25192   {
25193     try {
25194       (arg1)->SetTargetFrameBuffer(arg2);
25195     } catch (std::out_of_range& e) {
25196       {
25197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25198       };
25199     } catch (std::exception& e) {
25200       {
25201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25202       };
25203     } catch (...) {
25204       {
25205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25206       };
25207     }
25208   }
25209 }
25210
25211
25212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
25213   void * jresult ;
25214   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25215   Dali::FrameBufferImage result;
25216
25217   arg1 = (Dali::RenderTask *)jarg1;
25218   {
25219     try {
25220       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
25221     } catch (std::out_of_range& e) {
25222       {
25223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25224       };
25225     } catch (std::exception& e) {
25226       {
25227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25228       };
25229     } catch (...) {
25230       {
25231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25232       };
25233     }
25234   }
25235   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
25236   return jresult;
25237 }
25238
25239
25240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
25241   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25242   Dali::FrameBuffer arg2 ;
25243   Dali::FrameBuffer *argp2 ;
25244
25245   arg1 = (Dali::RenderTask *)jarg1;
25246   argp2 = (Dali::FrameBuffer *)jarg2;
25247   if (!argp2) {
25248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
25249     return ;
25250   }
25251   arg2 = *argp2;
25252   {
25253     try {
25254       (arg1)->SetFrameBuffer(arg2);
25255     } catch (std::out_of_range& e) {
25256       {
25257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25258       };
25259     } catch (std::exception& e) {
25260       {
25261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25262       };
25263     } catch (...) {
25264       {
25265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25266       };
25267     }
25268   }
25269 }
25270
25271
25272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
25273   void * jresult ;
25274   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25275   Dali::FrameBuffer result;
25276
25277   arg1 = (Dali::RenderTask *)jarg1;
25278   {
25279     try {
25280       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
25281     } catch (std::out_of_range& e) {
25282       {
25283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25284       };
25285     } catch (std::exception& e) {
25286       {
25287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25288       };
25289     } catch (...) {
25290       {
25291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25292       };
25293     }
25294   }
25295   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
25296   return jresult;
25297 }
25298
25299
25300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
25301   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25302   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
25303
25304   arg1 = (Dali::RenderTask *)jarg1;
25305   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
25306   {
25307     try {
25308       (arg1)->SetScreenToFrameBufferFunction(arg2);
25309     } catch (std::out_of_range& e) {
25310       {
25311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25312       };
25313     } catch (std::exception& e) {
25314       {
25315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25316       };
25317     } catch (...) {
25318       {
25319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25320       };
25321     }
25322   }
25323 }
25324
25325
25326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
25327   void * jresult ;
25328   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25329   Dali::RenderTask::ScreenToFrameBufferFunction result;
25330
25331   arg1 = (Dali::RenderTask *)jarg1;
25332   {
25333     try {
25334       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
25335     } catch (std::out_of_range& e) {
25336       {
25337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25338       };
25339     } catch (std::exception& e) {
25340       {
25341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25342       };
25343     } catch (...) {
25344       {
25345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25346       };
25347     }
25348   }
25349   jresult = (void *)result;
25350   return jresult;
25351 }
25352
25353
25354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
25355   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25356   Dali::Actor arg2 ;
25357   Dali::Actor *argp2 ;
25358
25359   arg1 = (Dali::RenderTask *)jarg1;
25360   argp2 = (Dali::Actor *)jarg2;
25361   if (!argp2) {
25362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25363     return ;
25364   }
25365   arg2 = *argp2;
25366   {
25367     try {
25368       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
25369     } catch (std::out_of_range& e) {
25370       {
25371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25372       };
25373     } catch (std::exception& e) {
25374       {
25375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25376       };
25377     } catch (...) {
25378       {
25379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25380       };
25381     }
25382   }
25383 }
25384
25385
25386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
25387   void * jresult ;
25388   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25389   Dali::Actor result;
25390
25391   arg1 = (Dali::RenderTask *)jarg1;
25392   {
25393     try {
25394       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
25395     } catch (std::out_of_range& e) {
25396       {
25397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25398       };
25399     } catch (std::exception& e) {
25400       {
25401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25402       };
25403     } catch (...) {
25404       {
25405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25406       };
25407     }
25408   }
25409   jresult = new Dali::Actor((const Dali::Actor &)result);
25410   return jresult;
25411 }
25412
25413
25414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
25415   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25416   Dali::Vector2 arg2 ;
25417   Dali::Vector2 *argp2 ;
25418
25419   arg1 = (Dali::RenderTask *)jarg1;
25420   argp2 = (Dali::Vector2 *)jarg2;
25421   if (!argp2) {
25422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25423     return ;
25424   }
25425   arg2 = *argp2;
25426   {
25427     try {
25428       (arg1)->SetViewportPosition(arg2);
25429     } catch (std::out_of_range& e) {
25430       {
25431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25432       };
25433     } catch (std::exception& e) {
25434       {
25435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25436       };
25437     } catch (...) {
25438       {
25439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25440       };
25441     }
25442   }
25443 }
25444
25445
25446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
25447   void * jresult ;
25448   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25449   Dali::Vector2 result;
25450
25451   arg1 = (Dali::RenderTask *)jarg1;
25452   {
25453     try {
25454       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
25455     } catch (std::out_of_range& e) {
25456       {
25457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25458       };
25459     } catch (std::exception& e) {
25460       {
25461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25462       };
25463     } catch (...) {
25464       {
25465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25466       };
25467     }
25468   }
25469   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25470   return jresult;
25471 }
25472
25473
25474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
25475   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25476   Dali::Vector2 arg2 ;
25477   Dali::Vector2 *argp2 ;
25478
25479   arg1 = (Dali::RenderTask *)jarg1;
25480   argp2 = (Dali::Vector2 *)jarg2;
25481   if (!argp2) {
25482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25483     return ;
25484   }
25485   arg2 = *argp2;
25486   {
25487     try {
25488       (arg1)->SetViewportSize(arg2);
25489     } catch (std::out_of_range& e) {
25490       {
25491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25492       };
25493     } catch (std::exception& e) {
25494       {
25495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25496       };
25497     } catch (...) {
25498       {
25499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25500       };
25501     }
25502   }
25503 }
25504
25505
25506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
25507   void * jresult ;
25508   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25509   Dali::Vector2 result;
25510
25511   arg1 = (Dali::RenderTask *)jarg1;
25512   {
25513     try {
25514       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
25515     } catch (std::out_of_range& e) {
25516       {
25517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25518       };
25519     } catch (std::exception& e) {
25520       {
25521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25522       };
25523     } catch (...) {
25524       {
25525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25526       };
25527     }
25528   }
25529   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25530   return jresult;
25531 }
25532
25533
25534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
25535   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25536   Dali::Viewport arg2 ;
25537   Dali::Viewport *argp2 ;
25538
25539   arg1 = (Dali::RenderTask *)jarg1;
25540   argp2 = (Dali::Viewport *)jarg2;
25541   if (!argp2) {
25542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
25543     return ;
25544   }
25545   arg2 = *argp2;
25546   {
25547     try {
25548       (arg1)->SetViewport(arg2);
25549     } catch (std::out_of_range& e) {
25550       {
25551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25552       };
25553     } catch (std::exception& e) {
25554       {
25555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25556       };
25557     } catch (...) {
25558       {
25559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25560       };
25561     }
25562   }
25563 }
25564
25565
25566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
25567   void * jresult ;
25568   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25569   Dali::Viewport result;
25570
25571   arg1 = (Dali::RenderTask *)jarg1;
25572   {
25573     try {
25574       result = ((Dali::RenderTask const *)arg1)->GetViewport();
25575     } catch (std::out_of_range& e) {
25576       {
25577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25578       };
25579     } catch (std::exception& e) {
25580       {
25581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25582       };
25583     } catch (...) {
25584       {
25585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25586       };
25587     }
25588   }
25589   jresult = new Dali::Viewport((const Dali::Viewport &)result);
25590   return jresult;
25591 }
25592
25593
25594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
25595   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25596   Dali::Vector4 *arg2 = 0 ;
25597
25598   arg1 = (Dali::RenderTask *)jarg1;
25599   arg2 = (Dali::Vector4 *)jarg2;
25600   if (!arg2) {
25601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
25602     return ;
25603   }
25604   {
25605     try {
25606       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
25607     } catch (std::out_of_range& e) {
25608       {
25609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25610       };
25611     } catch (std::exception& e) {
25612       {
25613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25614       };
25615     } catch (...) {
25616       {
25617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25618       };
25619     }
25620   }
25621 }
25622
25623
25624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
25625   void * jresult ;
25626   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25627   Dali::Vector4 result;
25628
25629   arg1 = (Dali::RenderTask *)jarg1;
25630   {
25631     try {
25632       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
25633     } catch (std::out_of_range& e) {
25634       {
25635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25636       };
25637     } catch (std::exception& e) {
25638       {
25639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25640       };
25641     } catch (...) {
25642       {
25643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25644       };
25645     }
25646   }
25647   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
25648   return jresult;
25649 }
25650
25651
25652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
25653   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25654   bool arg2 ;
25655
25656   arg1 = (Dali::RenderTask *)jarg1;
25657   arg2 = jarg2 ? true : false;
25658   {
25659     try {
25660       (arg1)->SetClearEnabled(arg2);
25661     } catch (std::out_of_range& e) {
25662       {
25663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25664       };
25665     } catch (std::exception& e) {
25666       {
25667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25668       };
25669     } catch (...) {
25670       {
25671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25672       };
25673     }
25674   }
25675 }
25676
25677
25678 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
25679   unsigned int jresult ;
25680   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25681   bool result;
25682
25683   arg1 = (Dali::RenderTask *)jarg1;
25684   {
25685     try {
25686       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
25687     } catch (std::out_of_range& e) {
25688       {
25689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25690       };
25691     } catch (std::exception& e) {
25692       {
25693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25694       };
25695     } catch (...) {
25696       {
25697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25698       };
25699     }
25700   }
25701   jresult = result;
25702   return jresult;
25703 }
25704
25705
25706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
25707   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25708   bool arg2 ;
25709
25710   arg1 = (Dali::RenderTask *)jarg1;
25711   arg2 = jarg2 ? true : false;
25712   {
25713     try {
25714       (arg1)->SetCullMode(arg2);
25715     } catch (std::out_of_range& e) {
25716       {
25717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25718       };
25719     } catch (std::exception& e) {
25720       {
25721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25722       };
25723     } catch (...) {
25724       {
25725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25726       };
25727     }
25728   }
25729 }
25730
25731
25732 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
25733   unsigned int jresult ;
25734   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25735   bool result;
25736
25737   arg1 = (Dali::RenderTask *)jarg1;
25738   {
25739     try {
25740       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
25741     } catch (std::out_of_range& e) {
25742       {
25743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25744       };
25745     } catch (std::exception& e) {
25746       {
25747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25748       };
25749     } catch (...) {
25750       {
25751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25752       };
25753     }
25754   }
25755   jresult = result;
25756   return jresult;
25757 }
25758
25759
25760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
25761   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25762   unsigned int arg2 ;
25763
25764   arg1 = (Dali::RenderTask *)jarg1;
25765   arg2 = (unsigned int)jarg2;
25766   {
25767     try {
25768       (arg1)->SetRefreshRate(arg2);
25769     } catch (std::out_of_range& e) {
25770       {
25771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25772       };
25773     } catch (std::exception& e) {
25774       {
25775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25776       };
25777     } catch (...) {
25778       {
25779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25780       };
25781     }
25782   }
25783 }
25784
25785
25786 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
25787   unsigned int jresult ;
25788   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25789   unsigned int result;
25790
25791   arg1 = (Dali::RenderTask *)jarg1;
25792   {
25793     try {
25794       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
25795     } catch (std::out_of_range& e) {
25796       {
25797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25798       };
25799     } catch (std::exception& e) {
25800       {
25801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25802       };
25803     } catch (...) {
25804       {
25805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25806       };
25807     }
25808   }
25809   jresult = result;
25810   return jresult;
25811 }
25812
25813
25814 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
25815   unsigned int jresult ;
25816   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25817   Dali::Vector3 *arg2 = 0 ;
25818   float *arg3 = 0 ;
25819   float *arg4 = 0 ;
25820   bool result;
25821
25822   arg1 = (Dali::RenderTask *)jarg1;
25823   arg2 = (Dali::Vector3 *)jarg2;
25824   if (!arg2) {
25825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
25826     return 0;
25827   }
25828   arg3 = (float *)jarg3;
25829   arg4 = (float *)jarg4;
25830   {
25831     try {
25832       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
25833     } catch (std::out_of_range& e) {
25834       {
25835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25836       };
25837     } catch (std::exception& e) {
25838       {
25839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25840       };
25841     } catch (...) {
25842       {
25843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25844       };
25845     }
25846   }
25847   jresult = result;
25848   return jresult;
25849 }
25850
25851
25852 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
25853   unsigned int jresult ;
25854   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25855   Dali::Actor arg2 ;
25856   float arg3 ;
25857   float arg4 ;
25858   float *arg5 = 0 ;
25859   float *arg6 = 0 ;
25860   Dali::Actor *argp2 ;
25861   bool result;
25862
25863   arg1 = (Dali::RenderTask *)jarg1;
25864   argp2 = (Dali::Actor *)jarg2;
25865   if (!argp2) {
25866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25867     return 0;
25868   }
25869   arg2 = *argp2;
25870   arg3 = (float)jarg3;
25871   arg4 = (float)jarg4;
25872   arg5 = (float *)jarg5;
25873   arg6 = (float *)jarg6;
25874   {
25875     try {
25876       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
25877     } catch (std::out_of_range& e) {
25878       {
25879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25880       };
25881     } catch (std::exception& e) {
25882       {
25883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25884       };
25885     } catch (...) {
25886       {
25887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25888       };
25889     }
25890   }
25891   jresult = result;
25892   return jresult;
25893 }
25894
25895
25896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
25897   void * jresult ;
25898   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25899   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
25900
25901   arg1 = (Dali::RenderTask *)jarg1;
25902   {
25903     try {
25904       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
25905     } catch (std::out_of_range& e) {
25906       {
25907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25908       };
25909     } catch (std::exception& e) {
25910       {
25911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25912       };
25913     } catch (...) {
25914       {
25915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25916       };
25917     }
25918   }
25919   jresult = (void *)result;
25920   return jresult;
25921 }
25922
25923
25924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
25925   void * jresult ;
25926   int arg1 ;
25927   Dali::TouchPoint::State arg2 ;
25928   float arg3 ;
25929   float arg4 ;
25930   Dali::TouchPoint *result = 0 ;
25931
25932   arg1 = (int)jarg1;
25933   arg2 = (Dali::TouchPoint::State)jarg2;
25934   arg3 = (float)jarg3;
25935   arg4 = (float)jarg4;
25936   {
25937     try {
25938       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
25939     } catch (std::out_of_range& e) {
25940       {
25941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25942       };
25943     } catch (std::exception& e) {
25944       {
25945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25946       };
25947     } catch (...) {
25948       {
25949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25950       };
25951     }
25952   }
25953   jresult = (void *)result;
25954   return jresult;
25955 }
25956
25957
25958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
25959   void * jresult ;
25960   int arg1 ;
25961   Dali::TouchPoint::State arg2 ;
25962   float arg3 ;
25963   float arg4 ;
25964   float arg5 ;
25965   float arg6 ;
25966   Dali::TouchPoint *result = 0 ;
25967
25968   arg1 = (int)jarg1;
25969   arg2 = (Dali::TouchPoint::State)jarg2;
25970   arg3 = (float)jarg3;
25971   arg4 = (float)jarg4;
25972   arg5 = (float)jarg5;
25973   arg6 = (float)jarg6;
25974   {
25975     try {
25976       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
25977     } catch (std::out_of_range& e) {
25978       {
25979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25980       };
25981     } catch (std::exception& e) {
25982       {
25983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25984       };
25985     } catch (...) {
25986       {
25987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25988       };
25989     }
25990   }
25991   jresult = (void *)result;
25992   return jresult;
25993 }
25994
25995
25996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
25997   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25998
25999   arg1 = (Dali::TouchPoint *)jarg1;
26000   {
26001     try {
26002       delete arg1;
26003     } catch (std::out_of_range& e) {
26004       {
26005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26006       };
26007     } catch (std::exception& e) {
26008       {
26009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26010       };
26011     } catch (...) {
26012       {
26013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26014       };
26015     }
26016   }
26017 }
26018
26019
26020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
26021   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26022   int arg2 ;
26023
26024   arg1 = (Dali::TouchPoint *)jarg1;
26025   arg2 = (int)jarg2;
26026   if (arg1) (arg1)->deviceId = arg2;
26027 }
26028
26029
26030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
26031   int jresult ;
26032   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26033   int result;
26034
26035   arg1 = (Dali::TouchPoint *)jarg1;
26036   result = (int) ((arg1)->deviceId);
26037   jresult = result;
26038   return jresult;
26039 }
26040
26041
26042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
26043   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26044   Dali::TouchPoint::State arg2 ;
26045
26046   arg1 = (Dali::TouchPoint *)jarg1;
26047   arg2 = (Dali::TouchPoint::State)jarg2;
26048   if (arg1) (arg1)->state = arg2;
26049 }
26050
26051
26052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
26053   int jresult ;
26054   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26055   Dali::TouchPoint::State result;
26056
26057   arg1 = (Dali::TouchPoint *)jarg1;
26058   result = (Dali::TouchPoint::State) ((arg1)->state);
26059   jresult = (int)result;
26060   return jresult;
26061 }
26062
26063
26064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
26065   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26066   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
26067
26068   arg1 = (Dali::TouchPoint *)jarg1;
26069   arg2 = (Dali::Actor *)jarg2;
26070   if (arg1) (arg1)->hitActor = *arg2;
26071 }
26072
26073
26074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
26075   void * jresult ;
26076   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26077   Dali::Actor *result = 0 ;
26078
26079   arg1 = (Dali::TouchPoint *)jarg1;
26080   result = (Dali::Actor *)& ((arg1)->hitActor);
26081   jresult = (void *)result;
26082   return jresult;
26083 }
26084
26085
26086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
26087   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26088   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26089
26090   arg1 = (Dali::TouchPoint *)jarg1;
26091   arg2 = (Dali::Vector2 *)jarg2;
26092   if (arg1) (arg1)->local = *arg2;
26093 }
26094
26095
26096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
26097   void * jresult ;
26098   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26099   Dali::Vector2 *result = 0 ;
26100
26101   arg1 = (Dali::TouchPoint *)jarg1;
26102   result = (Dali::Vector2 *)& ((arg1)->local);
26103   jresult = (void *)result;
26104   return jresult;
26105 }
26106
26107
26108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
26109   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26110   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26111
26112   arg1 = (Dali::TouchPoint *)jarg1;
26113   arg2 = (Dali::Vector2 *)jarg2;
26114   if (arg1) (arg1)->screen = *arg2;
26115 }
26116
26117
26118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
26119   void * jresult ;
26120   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26121   Dali::Vector2 *result = 0 ;
26122
26123   arg1 = (Dali::TouchPoint *)jarg1;
26124   result = (Dali::Vector2 *)& ((arg1)->screen);
26125   jresult = (void *)result;
26126   return jresult;
26127 }
26128
26129
26130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
26131   void * jresult ;
26132   Dali::TouchData *result = 0 ;
26133
26134   {
26135     try {
26136       result = (Dali::TouchData *)new Dali::TouchData();
26137     } catch (std::out_of_range& e) {
26138       {
26139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26140       };
26141     } catch (std::exception& e) {
26142       {
26143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26144       };
26145     } catch (...) {
26146       {
26147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26148       };
26149     }
26150   }
26151   jresult = (void *)result;
26152   return jresult;
26153 }
26154
26155
26156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
26157   void * jresult ;
26158   Dali::TouchData *arg1 = 0 ;
26159   Dali::TouchData *result = 0 ;
26160
26161   arg1 = (Dali::TouchData *)jarg1;
26162   if (!arg1) {
26163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26164     return 0;
26165   }
26166   {
26167     try {
26168       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
26169     } catch (std::out_of_range& e) {
26170       {
26171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26172       };
26173     } catch (std::exception& e) {
26174       {
26175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26176       };
26177     } catch (...) {
26178       {
26179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26180       };
26181     }
26182   }
26183   jresult = (void *)result;
26184   return jresult;
26185 }
26186
26187
26188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
26189   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26190
26191   arg1 = (Dali::TouchData *)jarg1;
26192   {
26193     try {
26194       delete arg1;
26195     } catch (std::out_of_range& e) {
26196       {
26197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26198       };
26199     } catch (std::exception& e) {
26200       {
26201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26202       };
26203     } catch (...) {
26204       {
26205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26206       };
26207     }
26208   }
26209 }
26210
26211
26212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
26213   void * jresult ;
26214   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26215   Dali::TouchData *arg2 = 0 ;
26216   Dali::TouchData *result = 0 ;
26217
26218   arg1 = (Dali::TouchData *)jarg1;
26219   arg2 = (Dali::TouchData *)jarg2;
26220   if (!arg2) {
26221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26222     return 0;
26223   }
26224   {
26225     try {
26226       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
26227     } catch (std::out_of_range& e) {
26228       {
26229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26230       };
26231     } catch (std::exception& e) {
26232       {
26233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26234       };
26235     } catch (...) {
26236       {
26237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26238       };
26239     }
26240   }
26241   jresult = (void *)result;
26242   return jresult;
26243 }
26244
26245
26246 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
26247   unsigned long jresult ;
26248   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26249   unsigned long result;
26250
26251   arg1 = (Dali::TouchData *)jarg1;
26252   {
26253     try {
26254       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
26255     } catch (std::out_of_range& e) {
26256       {
26257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26258       };
26259     } catch (std::exception& e) {
26260       {
26261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26262       };
26263     } catch (...) {
26264       {
26265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26266       };
26267     }
26268   }
26269   jresult = (unsigned long)result;
26270   return jresult;
26271 }
26272
26273
26274 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
26275   unsigned long jresult ;
26276   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26277   std::size_t result;
26278
26279   arg1 = (Dali::TouchData *)jarg1;
26280   {
26281     try {
26282       result = ((Dali::TouchData const *)arg1)->GetPointCount();
26283     } catch (std::out_of_range& e) {
26284       {
26285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26286       };
26287     } catch (std::exception& e) {
26288       {
26289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26290       };
26291     } catch (...) {
26292       {
26293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26294       };
26295     }
26296   }
26297   jresult = (unsigned long)result;
26298   return jresult;
26299 }
26300
26301
26302 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
26303   int jresult ;
26304   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26305   std::size_t arg2 ;
26306   int32_t result;
26307
26308   arg1 = (Dali::TouchData *)jarg1;
26309   arg2 = (std::size_t)jarg2;
26310   {
26311     try {
26312       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
26313     } catch (std::out_of_range& e) {
26314       {
26315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26316       };
26317     } catch (std::exception& e) {
26318       {
26319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26320       };
26321     } catch (...) {
26322       {
26323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26324       };
26325     }
26326   }
26327   jresult = result;
26328   return jresult;
26329 }
26330
26331
26332 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
26333   int jresult ;
26334   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26335   std::size_t arg2 ;
26336   Dali::PointState::Type result;
26337
26338   arg1 = (Dali::TouchData *)jarg1;
26339   arg2 = (std::size_t)jarg2;
26340   {
26341     try {
26342       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
26343     } catch (std::out_of_range& e) {
26344       {
26345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26346       };
26347     } catch (std::exception& e) {
26348       {
26349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26350       };
26351     } catch (...) {
26352       {
26353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26354       };
26355     }
26356   }
26357   jresult = (int)result;
26358   return jresult;
26359 }
26360
26361
26362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
26363   void * jresult ;
26364   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26365   std::size_t arg2 ;
26366   Dali::Actor result;
26367
26368   arg1 = (Dali::TouchData *)jarg1;
26369   arg2 = (std::size_t)jarg2;
26370   {
26371     try {
26372       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
26373     } catch (std::out_of_range& e) {
26374       {
26375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26376       };
26377     } catch (std::exception& e) {
26378       {
26379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26380       };
26381     } catch (...) {
26382       {
26383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26384       };
26385     }
26386   }
26387   jresult = new Dali::Actor((const Dali::Actor &)result);
26388   return jresult;
26389 }
26390
26391
26392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
26393   void * jresult ;
26394   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26395   std::size_t arg2 ;
26396   Dali::Vector2 *result = 0 ;
26397
26398   arg1 = (Dali::TouchData *)jarg1;
26399   arg2 = (std::size_t)jarg2;
26400   {
26401     try {
26402       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
26403     } catch (std::out_of_range& e) {
26404       {
26405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26406       };
26407     } catch (std::exception& e) {
26408       {
26409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26410       };
26411     } catch (...) {
26412       {
26413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26414       };
26415     }
26416   }
26417   jresult = (void *)result;
26418   return jresult;
26419 }
26420
26421
26422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
26423   void * jresult ;
26424   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26425   std::size_t arg2 ;
26426   Dali::Vector2 *result = 0 ;
26427
26428   arg1 = (Dali::TouchData *)jarg1;
26429   arg2 = (std::size_t)jarg2;
26430   {
26431     try {
26432       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
26433     } catch (std::out_of_range& e) {
26434       {
26435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26436       };
26437     } catch (std::exception& e) {
26438       {
26439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26440       };
26441     } catch (...) {
26442       {
26443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26444       };
26445     }
26446   }
26447   jresult = (void *)result;
26448   return jresult;
26449 }
26450
26451
26452 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
26453   float jresult ;
26454   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26455   std::size_t arg2 ;
26456   float result;
26457
26458   arg1 = (Dali::TouchData *)jarg1;
26459   arg2 = (std::size_t)jarg2;
26460   {
26461     try {
26462       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
26463     } catch (std::out_of_range& e) {
26464       {
26465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26466       };
26467     } catch (std::exception& e) {
26468       {
26469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26470       };
26471     } catch (...) {
26472       {
26473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26474       };
26475     }
26476   }
26477   jresult = result;
26478   return jresult;
26479 }
26480
26481
26482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
26483   void * jresult ;
26484   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26485   std::size_t arg2 ;
26486   Dali::Vector2 *result = 0 ;
26487
26488   arg1 = (Dali::TouchData *)jarg1;
26489   arg2 = (std::size_t)jarg2;
26490   {
26491     try {
26492       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
26493     } catch (std::out_of_range& e) {
26494       {
26495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26496       };
26497     } catch (std::exception& e) {
26498       {
26499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26500       };
26501     } catch (...) {
26502       {
26503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26504       };
26505     }
26506   }
26507   jresult = (void *)result;
26508   return jresult;
26509 }
26510
26511
26512 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
26513   float jresult ;
26514   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26515   std::size_t arg2 ;
26516   float result;
26517
26518   arg1 = (Dali::TouchData *)jarg1;
26519   arg2 = (std::size_t)jarg2;
26520   {
26521     try {
26522       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
26523     } catch (std::out_of_range& e) {
26524       {
26525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26526       };
26527     } catch (std::exception& e) {
26528       {
26529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26530       };
26531     } catch (...) {
26532       {
26533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26534       };
26535     }
26536   }
26537   jresult = result;
26538   return jresult;
26539 }
26540
26541
26542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
26543   void * jresult ;
26544   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26545   std::size_t arg2 ;
26546   Dali::Degree result;
26547
26548   arg1 = (Dali::TouchData *)jarg1;
26549   arg2 = (std::size_t)jarg2;
26550   {
26551     try {
26552       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
26553     } catch (std::out_of_range& e) {
26554       {
26555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26556       };
26557     } catch (std::exception& e) {
26558       {
26559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26560       };
26561     } catch (...) {
26562       {
26563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26564       };
26565     }
26566   }
26567   jresult = new Dali::Degree((const Dali::Degree &)result);
26568   return jresult;
26569 }
26570
26571
26572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
26573   void * jresult ;
26574   Dali::GestureDetector *result = 0 ;
26575
26576   {
26577     try {
26578       result = (Dali::GestureDetector *)new Dali::GestureDetector();
26579     } catch (std::out_of_range& e) {
26580       {
26581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26582       };
26583     } catch (std::exception& e) {
26584       {
26585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26586       };
26587     } catch (...) {
26588       {
26589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26590       };
26591     }
26592   }
26593   jresult = (void *)result;
26594   return jresult;
26595 }
26596
26597
26598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
26599   void * jresult ;
26600   Dali::BaseHandle arg1 ;
26601   Dali::BaseHandle *argp1 ;
26602   Dali::GestureDetector result;
26603
26604   argp1 = (Dali::BaseHandle *)jarg1;
26605   if (!argp1) {
26606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26607     return 0;
26608   }
26609   arg1 = *argp1;
26610   {
26611     try {
26612       result = Dali::GestureDetector::DownCast(arg1);
26613     } catch (std::out_of_range& e) {
26614       {
26615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26616       };
26617     } catch (std::exception& e) {
26618       {
26619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26620       };
26621     } catch (...) {
26622       {
26623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26624       };
26625     }
26626   }
26627   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
26628   return jresult;
26629 }
26630
26631
26632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
26633   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26634
26635   arg1 = (Dali::GestureDetector *)jarg1;
26636   {
26637     try {
26638       delete arg1;
26639     } catch (std::out_of_range& e) {
26640       {
26641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26642       };
26643     } catch (std::exception& e) {
26644       {
26645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26646       };
26647     } catch (...) {
26648       {
26649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26650       };
26651     }
26652   }
26653 }
26654
26655
26656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
26657   void * jresult ;
26658   Dali::GestureDetector *arg1 = 0 ;
26659   Dali::GestureDetector *result = 0 ;
26660
26661   arg1 = (Dali::GestureDetector *)jarg1;
26662   if (!arg1) {
26663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26664     return 0;
26665   }
26666   {
26667     try {
26668       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
26669     } catch (std::out_of_range& e) {
26670       {
26671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26672       };
26673     } catch (std::exception& e) {
26674       {
26675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26676       };
26677     } catch (...) {
26678       {
26679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26680       };
26681     }
26682   }
26683   jresult = (void *)result;
26684   return jresult;
26685 }
26686
26687
26688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
26689   void * jresult ;
26690   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26691   Dali::GestureDetector *arg2 = 0 ;
26692   Dali::GestureDetector *result = 0 ;
26693
26694   arg1 = (Dali::GestureDetector *)jarg1;
26695   arg2 = (Dali::GestureDetector *)jarg2;
26696   if (!arg2) {
26697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26698     return 0;
26699   }
26700   {
26701     try {
26702       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
26703     } catch (std::out_of_range& e) {
26704       {
26705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26706       };
26707     } catch (std::exception& e) {
26708       {
26709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26710       };
26711     } catch (...) {
26712       {
26713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26714       };
26715     }
26716   }
26717   jresult = (void *)result;
26718   return jresult;
26719 }
26720
26721
26722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
26723   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26724   Dali::Actor arg2 ;
26725   Dali::Actor *argp2 ;
26726
26727   arg1 = (Dali::GestureDetector *)jarg1;
26728   argp2 = (Dali::Actor *)jarg2;
26729   if (!argp2) {
26730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26731     return ;
26732   }
26733   arg2 = *argp2;
26734   {
26735     try {
26736       (arg1)->Attach(arg2);
26737     } catch (std::out_of_range& e) {
26738       {
26739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26740       };
26741     } catch (std::exception& e) {
26742       {
26743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26744       };
26745     } catch (...) {
26746       {
26747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26748       };
26749     }
26750   }
26751 }
26752
26753
26754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
26755   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26756   Dali::Actor arg2 ;
26757   Dali::Actor *argp2 ;
26758
26759   arg1 = (Dali::GestureDetector *)jarg1;
26760   argp2 = (Dali::Actor *)jarg2;
26761   if (!argp2) {
26762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26763     return ;
26764   }
26765   arg2 = *argp2;
26766   {
26767     try {
26768       (arg1)->Detach(arg2);
26769     } catch (std::out_of_range& e) {
26770       {
26771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26772       };
26773     } catch (std::exception& e) {
26774       {
26775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26776       };
26777     } catch (...) {
26778       {
26779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26780       };
26781     }
26782   }
26783 }
26784
26785
26786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
26787   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26788
26789   arg1 = (Dali::GestureDetector *)jarg1;
26790   {
26791     try {
26792       (arg1)->DetachAll();
26793     } catch (std::out_of_range& e) {
26794       {
26795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26796       };
26797     } catch (std::exception& e) {
26798       {
26799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26800       };
26801     } catch (...) {
26802       {
26803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26804       };
26805     }
26806   }
26807 }
26808
26809
26810 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
26811   unsigned long jresult ;
26812   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26813   size_t result;
26814
26815   arg1 = (Dali::GestureDetector *)jarg1;
26816   {
26817     try {
26818       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
26819     } catch (std::out_of_range& e) {
26820       {
26821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26822       };
26823     } catch (std::exception& e) {
26824       {
26825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26826       };
26827     } catch (...) {
26828       {
26829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26830       };
26831     }
26832   }
26833   jresult = (unsigned long)result;
26834   return jresult;
26835 }
26836
26837
26838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
26839   void * jresult ;
26840   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26841   size_t arg2 ;
26842   Dali::Actor result;
26843
26844   arg1 = (Dali::GestureDetector *)jarg1;
26845   arg2 = (size_t)jarg2;
26846   {
26847     try {
26848       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
26849     } catch (std::out_of_range& e) {
26850       {
26851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26852       };
26853     } catch (std::exception& e) {
26854       {
26855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26856       };
26857     } catch (...) {
26858       {
26859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26860       };
26861     }
26862   }
26863   jresult = new Dali::Actor((const Dali::Actor &)result);
26864   return jresult;
26865 }
26866
26867
26868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
26869   void * jresult ;
26870   Dali::Gesture *arg1 = 0 ;
26871   Dali::Gesture *result = 0 ;
26872
26873   arg1 = (Dali::Gesture *)jarg1;
26874   if (!arg1) {
26875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26876     return 0;
26877   }
26878   {
26879     try {
26880       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
26881     } catch (std::out_of_range& e) {
26882       {
26883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26884       };
26885     } catch (std::exception& e) {
26886       {
26887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26888       };
26889     } catch (...) {
26890       {
26891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26892       };
26893     }
26894   }
26895   jresult = (void *)result;
26896   return jresult;
26897 }
26898
26899
26900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
26901   void * jresult ;
26902   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26903   Dali::Gesture *arg2 = 0 ;
26904   Dali::Gesture *result = 0 ;
26905
26906   arg1 = (Dali::Gesture *)jarg1;
26907   arg2 = (Dali::Gesture *)jarg2;
26908   if (!arg2) {
26909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26910     return 0;
26911   }
26912   {
26913     try {
26914       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
26915     } catch (std::out_of_range& e) {
26916       {
26917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26918       };
26919     } catch (std::exception& e) {
26920       {
26921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26922       };
26923     } catch (...) {
26924       {
26925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26926       };
26927     }
26928   }
26929   jresult = (void *)result;
26930   return jresult;
26931 }
26932
26933
26934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
26935   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26936
26937   arg1 = (Dali::Gesture *)jarg1;
26938   {
26939     try {
26940       delete arg1;
26941     } catch (std::out_of_range& e) {
26942       {
26943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26944       };
26945     } catch (std::exception& e) {
26946       {
26947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26948       };
26949     } catch (...) {
26950       {
26951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26952       };
26953     }
26954   }
26955 }
26956
26957
26958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
26959   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26960   Dali::Gesture::Type arg2 ;
26961
26962   arg1 = (Dali::Gesture *)jarg1;
26963   arg2 = (Dali::Gesture::Type)jarg2;
26964   if (arg1) (arg1)->type = arg2;
26965 }
26966
26967
26968 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
26969   int jresult ;
26970   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26971   Dali::Gesture::Type result;
26972
26973   arg1 = (Dali::Gesture *)jarg1;
26974   result = (Dali::Gesture::Type) ((arg1)->type);
26975   jresult = (int)result;
26976   return jresult;
26977 }
26978
26979
26980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
26981   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26982   Dali::Gesture::State arg2 ;
26983
26984   arg1 = (Dali::Gesture *)jarg1;
26985   arg2 = (Dali::Gesture::State)jarg2;
26986   if (arg1) (arg1)->state = arg2;
26987 }
26988
26989
26990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
26991   int jresult ;
26992   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26993   Dali::Gesture::State result;
26994
26995   arg1 = (Dali::Gesture *)jarg1;
26996   result = (Dali::Gesture::State) ((arg1)->state);
26997   jresult = (int)result;
26998   return jresult;
26999 }
27000
27001
27002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
27003   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27004   unsigned int arg2 ;
27005
27006   arg1 = (Dali::Gesture *)jarg1;
27007   arg2 = (unsigned int)jarg2;
27008   if (arg1) (arg1)->time = arg2;
27009 }
27010
27011
27012 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
27013   unsigned int jresult ;
27014   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27015   unsigned int result;
27016
27017   arg1 = (Dali::Gesture *)jarg1;
27018   result = (unsigned int) ((arg1)->time);
27019   jresult = result;
27020   return jresult;
27021 }
27022
27023
27024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
27025   void * jresult ;
27026   Dali::HoverEvent *result = 0 ;
27027
27028   {
27029     try {
27030       result = (Dali::HoverEvent *)new Dali::HoverEvent();
27031     } catch (std::out_of_range& e) {
27032       {
27033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27034       };
27035     } catch (std::exception& e) {
27036       {
27037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27038       };
27039     } catch (...) {
27040       {
27041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27042       };
27043     }
27044   }
27045   jresult = (void *)result;
27046   return jresult;
27047 }
27048
27049
27050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
27051   void * jresult ;
27052   unsigned long arg1 ;
27053   Dali::HoverEvent *result = 0 ;
27054
27055   arg1 = (unsigned long)jarg1;
27056   {
27057     try {
27058       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
27059     } catch (std::out_of_range& e) {
27060       {
27061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27062       };
27063     } catch (std::exception& e) {
27064       {
27065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27066       };
27067     } catch (...) {
27068       {
27069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27070       };
27071     }
27072   }
27073   jresult = (void *)result;
27074   return jresult;
27075 }
27076
27077
27078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
27079   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27080
27081   arg1 = (Dali::HoverEvent *)jarg1;
27082   {
27083     try {
27084       delete arg1;
27085     } catch (std::out_of_range& e) {
27086       {
27087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27088       };
27089     } catch (std::exception& e) {
27090       {
27091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27092       };
27093     } catch (...) {
27094       {
27095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27096       };
27097     }
27098   }
27099 }
27100
27101
27102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
27103   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27104   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
27105
27106   arg1 = (Dali::HoverEvent *)jarg1;
27107   arg2 = (Dali::TouchPointContainer *)jarg2;
27108   if (arg1) (arg1)->points = *arg2;
27109 }
27110
27111
27112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
27113   void * jresult ;
27114   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27115   Dali::TouchPointContainer *result = 0 ;
27116
27117   arg1 = (Dali::HoverEvent *)jarg1;
27118   result = (Dali::TouchPointContainer *)& ((arg1)->points);
27119   jresult = (void *)result;
27120   return jresult;
27121 }
27122
27123
27124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
27125   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27126   unsigned long arg2 ;
27127
27128   arg1 = (Dali::HoverEvent *)jarg1;
27129   arg2 = (unsigned long)jarg2;
27130   if (arg1) (arg1)->time = arg2;
27131 }
27132
27133
27134 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
27135   unsigned long jresult ;
27136   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27137   unsigned long result;
27138
27139   arg1 = (Dali::HoverEvent *)jarg1;
27140   result = (unsigned long) ((arg1)->time);
27141   jresult = (unsigned long)result;
27142   return jresult;
27143 }
27144
27145
27146 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
27147   unsigned int jresult ;
27148   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27149   unsigned int result;
27150
27151   arg1 = (Dali::HoverEvent *)jarg1;
27152   {
27153     try {
27154       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
27155     } catch (std::out_of_range& e) {
27156       {
27157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27158       };
27159     } catch (std::exception& e) {
27160       {
27161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27162       };
27163     } catch (...) {
27164       {
27165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27166       };
27167     }
27168   }
27169   jresult = result;
27170   return jresult;
27171 }
27172
27173
27174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
27175   void * jresult ;
27176   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27177   unsigned int arg2 ;
27178   Dali::TouchPoint *result = 0 ;
27179
27180   arg1 = (Dali::HoverEvent *)jarg1;
27181   arg2 = (unsigned int)jarg2;
27182   {
27183     try {
27184       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
27185     } catch (std::out_of_range& e) {
27186       {
27187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27188       };
27189     } catch (std::exception& e) {
27190       {
27191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27192       };
27193     } catch (...) {
27194       {
27195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27196       };
27197     }
27198   }
27199   jresult = (void *)result;
27200   return jresult;
27201 }
27202
27203
27204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
27205   void * jresult ;
27206   Dali::KeyEvent *result = 0 ;
27207
27208   {
27209     try {
27210       result = (Dali::KeyEvent *)new Dali::KeyEvent();
27211     } catch (std::out_of_range& e) {
27212       {
27213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27214       };
27215     } catch (std::exception& e) {
27216       {
27217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27218       };
27219     } catch (...) {
27220       {
27221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27222       };
27223     }
27224   }
27225   jresult = (void *)result;
27226   return jresult;
27227 }
27228
27229
27230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
27231   void * jresult ;
27232   std::string *arg1 = 0 ;
27233   std::string *arg2 = 0 ;
27234   int arg3 ;
27235   int arg4 ;
27236   unsigned long arg5 ;
27237   Dali::KeyEvent::State *arg6 = 0 ;
27238   Dali::KeyEvent::State temp6 ;
27239   Dali::KeyEvent *result = 0 ;
27240
27241   if (!jarg1) {
27242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27243     return 0;
27244   }
27245   std::string arg1_str(jarg1);
27246   arg1 = &arg1_str;
27247   if (!jarg2) {
27248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27249     return 0;
27250   }
27251   std::string arg2_str(jarg2);
27252   arg2 = &arg2_str;
27253   arg3 = (int)jarg3;
27254   arg4 = (int)jarg4;
27255   arg5 = (unsigned long)jarg5;
27256   temp6 = (Dali::KeyEvent::State)jarg6;
27257   arg6 = &temp6;
27258   {
27259     try {
27260       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
27261     } catch (std::out_of_range& e) {
27262       {
27263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27264       };
27265     } catch (std::exception& e) {
27266       {
27267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27268       };
27269     } catch (...) {
27270       {
27271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27272       };
27273     }
27274   }
27275   jresult = (void *)result;
27276
27277   //argout typemap for const std::string&
27278
27279
27280   //argout typemap for const std::string&
27281
27282   return jresult;
27283 }
27284
27285
27286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
27287   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27288
27289   arg1 = (Dali::KeyEvent *)jarg1;
27290   {
27291     try {
27292       delete arg1;
27293     } catch (std::out_of_range& e) {
27294       {
27295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27296       };
27297     } catch (std::exception& e) {
27298       {
27299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27300       };
27301     } catch (...) {
27302       {
27303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27304       };
27305     }
27306   }
27307 }
27308
27309
27310 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
27311   unsigned int jresult ;
27312   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27313   bool result;
27314
27315   arg1 = (Dali::KeyEvent *)jarg1;
27316   {
27317     try {
27318       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
27319     } catch (std::out_of_range& e) {
27320       {
27321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27322       };
27323     } catch (std::exception& e) {
27324       {
27325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27326       };
27327     } catch (...) {
27328       {
27329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27330       };
27331     }
27332   }
27333   jresult = result;
27334   return jresult;
27335 }
27336
27337
27338 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
27339   unsigned int jresult ;
27340   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27341   bool result;
27342
27343   arg1 = (Dali::KeyEvent *)jarg1;
27344   {
27345     try {
27346       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
27347     } catch (std::out_of_range& e) {
27348       {
27349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27350       };
27351     } catch (std::exception& e) {
27352       {
27353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27354       };
27355     } catch (...) {
27356       {
27357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27358       };
27359     }
27360   }
27361   jresult = result;
27362   return jresult;
27363 }
27364
27365
27366 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
27367   unsigned int jresult ;
27368   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27369   bool result;
27370
27371   arg1 = (Dali::KeyEvent *)jarg1;
27372   {
27373     try {
27374       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
27375     } catch (std::out_of_range& e) {
27376       {
27377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27378       };
27379     } catch (std::exception& e) {
27380       {
27381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27382       };
27383     } catch (...) {
27384       {
27385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27386       };
27387     }
27388   }
27389   jresult = result;
27390   return jresult;
27391 }
27392
27393
27394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
27395   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27396   std::string *arg2 = 0 ;
27397
27398   arg1 = (Dali::KeyEvent *)jarg1;
27399   if (!jarg2) {
27400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27401     return ;
27402   }
27403   std::string arg2_str(jarg2);
27404   arg2 = &arg2_str;
27405   if (arg1) (arg1)->keyPressedName = *arg2;
27406
27407   //argout typemap for const std::string&
27408
27409 }
27410
27411
27412 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
27413   char * jresult ;
27414   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27415   std::string *result = 0 ;
27416
27417   arg1 = (Dali::KeyEvent *)jarg1;
27418   result = (std::string *) & ((arg1)->keyPressedName);
27419   jresult = SWIG_csharp_string_callback(result->c_str());
27420   return jresult;
27421 }
27422
27423
27424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
27425   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27426   std::string *arg2 = 0 ;
27427
27428   arg1 = (Dali::KeyEvent *)jarg1;
27429   if (!jarg2) {
27430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27431     return ;
27432   }
27433   std::string arg2_str(jarg2);
27434   arg2 = &arg2_str;
27435   if (arg1) (arg1)->keyPressed = *arg2;
27436
27437   //argout typemap for const std::string&
27438
27439 }
27440
27441
27442 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
27443   char * jresult ;
27444   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27445   std::string *result = 0 ;
27446
27447   arg1 = (Dali::KeyEvent *)jarg1;
27448   result = (std::string *) & ((arg1)->keyPressed);
27449   jresult = SWIG_csharp_string_callback(result->c_str());
27450   return jresult;
27451 }
27452
27453
27454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
27455   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27456   int arg2 ;
27457
27458   arg1 = (Dali::KeyEvent *)jarg1;
27459   arg2 = (int)jarg2;
27460   if (arg1) (arg1)->keyCode = arg2;
27461 }
27462
27463
27464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
27465   int jresult ;
27466   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27467   int result;
27468
27469   arg1 = (Dali::KeyEvent *)jarg1;
27470   result = (int) ((arg1)->keyCode);
27471   jresult = result;
27472   return jresult;
27473 }
27474
27475
27476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
27477   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27478   int arg2 ;
27479
27480   arg1 = (Dali::KeyEvent *)jarg1;
27481   arg2 = (int)jarg2;
27482   if (arg1) (arg1)->keyModifier = arg2;
27483 }
27484
27485
27486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
27487   int jresult ;
27488   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27489   int result;
27490
27491   arg1 = (Dali::KeyEvent *)jarg1;
27492   result = (int) ((arg1)->keyModifier);
27493   jresult = result;
27494   return jresult;
27495 }
27496
27497
27498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
27499   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27500   unsigned long arg2 ;
27501
27502   arg1 = (Dali::KeyEvent *)jarg1;
27503   arg2 = (unsigned long)jarg2;
27504   if (arg1) (arg1)->time = arg2;
27505 }
27506
27507
27508 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
27509   unsigned long jresult ;
27510   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27511   unsigned long result;
27512
27513   arg1 = (Dali::KeyEvent *)jarg1;
27514   result = (unsigned long) ((arg1)->time);
27515   jresult = (unsigned long)result;
27516   return jresult;
27517 }
27518
27519
27520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
27521   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27522   Dali::KeyEvent::State arg2 ;
27523
27524   arg1 = (Dali::KeyEvent *)jarg1;
27525   arg2 = (Dali::KeyEvent::State)jarg2;
27526   if (arg1) (arg1)->state = arg2;
27527 }
27528
27529
27530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
27531   int jresult ;
27532   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27533   Dali::KeyEvent::State result;
27534
27535   arg1 = (Dali::KeyEvent *)jarg1;
27536   result = (Dali::KeyEvent::State) ((arg1)->state);
27537   jresult = (int)result;
27538   return jresult;
27539 }
27540
27541
27542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
27543   void * jresult ;
27544   Dali::LongPressGestureDetector *result = 0 ;
27545
27546   {
27547     try {
27548       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
27549     } catch (std::out_of_range& e) {
27550       {
27551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27552       };
27553     } catch (std::exception& e) {
27554       {
27555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27556       };
27557     } catch (...) {
27558       {
27559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27560       };
27561     }
27562   }
27563   jresult = (void *)result;
27564   return jresult;
27565 }
27566
27567
27568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
27569   void * jresult ;
27570   Dali::LongPressGestureDetector result;
27571
27572   {
27573     try {
27574       result = Dali::LongPressGestureDetector::New();
27575     } catch (std::out_of_range& e) {
27576       {
27577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27578       };
27579     } catch (std::exception& e) {
27580       {
27581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27582       };
27583     } catch (...) {
27584       {
27585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27586       };
27587     }
27588   }
27589   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27590   return jresult;
27591 }
27592
27593
27594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
27595   void * jresult ;
27596   unsigned int arg1 ;
27597   Dali::LongPressGestureDetector result;
27598
27599   arg1 = (unsigned int)jarg1;
27600   {
27601     try {
27602       result = Dali::LongPressGestureDetector::New(arg1);
27603     } catch (std::out_of_range& e) {
27604       {
27605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27606       };
27607     } catch (std::exception& e) {
27608       {
27609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27610       };
27611     } catch (...) {
27612       {
27613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27614       };
27615     }
27616   }
27617   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27618   return jresult;
27619 }
27620
27621
27622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
27623   void * jresult ;
27624   unsigned int arg1 ;
27625   unsigned int arg2 ;
27626   Dali::LongPressGestureDetector result;
27627
27628   arg1 = (unsigned int)jarg1;
27629   arg2 = (unsigned int)jarg2;
27630   {
27631     try {
27632       result = Dali::LongPressGestureDetector::New(arg1,arg2);
27633     } catch (std::out_of_range& e) {
27634       {
27635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27636       };
27637     } catch (std::exception& e) {
27638       {
27639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27640       };
27641     } catch (...) {
27642       {
27643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27644       };
27645     }
27646   }
27647   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27648   return jresult;
27649 }
27650
27651
27652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
27653   void * jresult ;
27654   Dali::BaseHandle arg1 ;
27655   Dali::BaseHandle *argp1 ;
27656   Dali::LongPressGestureDetector result;
27657
27658   argp1 = (Dali::BaseHandle *)jarg1;
27659   if (!argp1) {
27660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27661     return 0;
27662   }
27663   arg1 = *argp1;
27664   {
27665     try {
27666       result = Dali::LongPressGestureDetector::DownCast(arg1);
27667     } catch (std::out_of_range& e) {
27668       {
27669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27670       };
27671     } catch (std::exception& e) {
27672       {
27673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27674       };
27675     } catch (...) {
27676       {
27677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27678       };
27679     }
27680   }
27681   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27682   return jresult;
27683 }
27684
27685
27686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
27687   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27688
27689   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27690   {
27691     try {
27692       delete arg1;
27693     } catch (std::out_of_range& e) {
27694       {
27695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27696       };
27697     } catch (std::exception& e) {
27698       {
27699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27700       };
27701     } catch (...) {
27702       {
27703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27704       };
27705     }
27706   }
27707 }
27708
27709
27710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
27711   void * jresult ;
27712   Dali::LongPressGestureDetector *arg1 = 0 ;
27713   Dali::LongPressGestureDetector *result = 0 ;
27714
27715   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27716   if (!arg1) {
27717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27718     return 0;
27719   }
27720   {
27721     try {
27722       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
27723     } catch (std::out_of_range& e) {
27724       {
27725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27726       };
27727     } catch (std::exception& e) {
27728       {
27729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27730       };
27731     } catch (...) {
27732       {
27733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27734       };
27735     }
27736   }
27737   jresult = (void *)result;
27738   return jresult;
27739 }
27740
27741
27742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
27743   void * jresult ;
27744   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27745   Dali::LongPressGestureDetector *arg2 = 0 ;
27746   Dali::LongPressGestureDetector *result = 0 ;
27747
27748   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27749   arg2 = (Dali::LongPressGestureDetector *)jarg2;
27750   if (!arg2) {
27751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27752     return 0;
27753   }
27754   {
27755     try {
27756       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
27757     } catch (std::out_of_range& e) {
27758       {
27759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27760       };
27761     } catch (std::exception& e) {
27762       {
27763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27764       };
27765     } catch (...) {
27766       {
27767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27768       };
27769     }
27770   }
27771   jresult = (void *)result;
27772   return jresult;
27773 }
27774
27775
27776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
27777   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27778   unsigned int arg2 ;
27779
27780   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27781   arg2 = (unsigned int)jarg2;
27782   {
27783     try {
27784       (arg1)->SetTouchesRequired(arg2);
27785     } catch (std::out_of_range& e) {
27786       {
27787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27788       };
27789     } catch (std::exception& e) {
27790       {
27791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27792       };
27793     } catch (...) {
27794       {
27795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27796       };
27797     }
27798   }
27799 }
27800
27801
27802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
27803   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27804   unsigned int arg2 ;
27805   unsigned int arg3 ;
27806
27807   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27808   arg2 = (unsigned int)jarg2;
27809   arg3 = (unsigned int)jarg3;
27810   {
27811     try {
27812       (arg1)->SetTouchesRequired(arg2,arg3);
27813     } catch (std::out_of_range& e) {
27814       {
27815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27816       };
27817     } catch (std::exception& e) {
27818       {
27819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27820       };
27821     } catch (...) {
27822       {
27823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27824       };
27825     }
27826   }
27827 }
27828
27829
27830 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
27831   unsigned int jresult ;
27832   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27833   unsigned int result;
27834
27835   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27836   {
27837     try {
27838       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
27839     } catch (std::out_of_range& e) {
27840       {
27841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27842       };
27843     } catch (std::exception& e) {
27844       {
27845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27846       };
27847     } catch (...) {
27848       {
27849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27850       };
27851     }
27852   }
27853   jresult = result;
27854   return jresult;
27855 }
27856
27857
27858 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
27859   unsigned int jresult ;
27860   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27861   unsigned int result;
27862
27863   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27864   {
27865     try {
27866       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
27867     } catch (std::out_of_range& e) {
27868       {
27869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27870       };
27871     } catch (std::exception& e) {
27872       {
27873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27874       };
27875     } catch (...) {
27876       {
27877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27878       };
27879     }
27880   }
27881   jresult = result;
27882   return jresult;
27883 }
27884
27885
27886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
27887   void * jresult ;
27888   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27889   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
27890
27891   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27892   {
27893     try {
27894       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
27895     } catch (std::out_of_range& e) {
27896       {
27897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27898       };
27899     } catch (std::exception& e) {
27900       {
27901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27902       };
27903     } catch (...) {
27904       {
27905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27906       };
27907     }
27908   }
27909   jresult = (void *)result;
27910   return jresult;
27911 }
27912
27913
27914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
27915   void * jresult ;
27916   Dali::Gesture::State arg1 ;
27917   Dali::LongPressGesture *result = 0 ;
27918
27919   arg1 = (Dali::Gesture::State)jarg1;
27920   {
27921     try {
27922       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
27923     } catch (std::out_of_range& e) {
27924       {
27925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27926       };
27927     } catch (std::exception& e) {
27928       {
27929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27930       };
27931     } catch (...) {
27932       {
27933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27934       };
27935     }
27936   }
27937   jresult = (void *)result;
27938   return jresult;
27939 }
27940
27941
27942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
27943   void * jresult ;
27944   Dali::LongPressGesture *arg1 = 0 ;
27945   Dali::LongPressGesture *result = 0 ;
27946
27947   arg1 = (Dali::LongPressGesture *)jarg1;
27948   if (!arg1) {
27949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
27950     return 0;
27951   }
27952   {
27953     try {
27954       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
27955     } catch (std::out_of_range& e) {
27956       {
27957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27958       };
27959     } catch (std::exception& e) {
27960       {
27961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27962       };
27963     } catch (...) {
27964       {
27965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27966       };
27967     }
27968   }
27969   jresult = (void *)result;
27970   return jresult;
27971 }
27972
27973
27974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
27975   void * jresult ;
27976   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27977   Dali::LongPressGesture *arg2 = 0 ;
27978   Dali::LongPressGesture *result = 0 ;
27979
27980   arg1 = (Dali::LongPressGesture *)jarg1;
27981   arg2 = (Dali::LongPressGesture *)jarg2;
27982   if (!arg2) {
27983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
27984     return 0;
27985   }
27986   {
27987     try {
27988       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
27989     } catch (std::out_of_range& e) {
27990       {
27991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27992       };
27993     } catch (std::exception& e) {
27994       {
27995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27996       };
27997     } catch (...) {
27998       {
27999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28000       };
28001     }
28002   }
28003   jresult = (void *)result;
28004   return jresult;
28005 }
28006
28007
28008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
28009   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28010
28011   arg1 = (Dali::LongPressGesture *)jarg1;
28012   {
28013     try {
28014       delete arg1;
28015     } catch (std::out_of_range& e) {
28016       {
28017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28018       };
28019     } catch (std::exception& e) {
28020       {
28021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28022       };
28023     } catch (...) {
28024       {
28025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28026       };
28027     }
28028   }
28029 }
28030
28031
28032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
28033   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28034   unsigned int arg2 ;
28035
28036   arg1 = (Dali::LongPressGesture *)jarg1;
28037   arg2 = (unsigned int)jarg2;
28038   if (arg1) (arg1)->numberOfTouches = arg2;
28039 }
28040
28041
28042 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
28043   unsigned int jresult ;
28044   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28045   unsigned int result;
28046
28047   arg1 = (Dali::LongPressGesture *)jarg1;
28048   result = (unsigned int) ((arg1)->numberOfTouches);
28049   jresult = result;
28050   return jresult;
28051 }
28052
28053
28054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
28055   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28056   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28057
28058   arg1 = (Dali::LongPressGesture *)jarg1;
28059   arg2 = (Dali::Vector2 *)jarg2;
28060   if (arg1) (arg1)->screenPoint = *arg2;
28061 }
28062
28063
28064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
28065   void * jresult ;
28066   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28067   Dali::Vector2 *result = 0 ;
28068
28069   arg1 = (Dali::LongPressGesture *)jarg1;
28070   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
28071   jresult = (void *)result;
28072   return jresult;
28073 }
28074
28075
28076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
28077   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28078   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28079
28080   arg1 = (Dali::LongPressGesture *)jarg1;
28081   arg2 = (Dali::Vector2 *)jarg2;
28082   if (arg1) (arg1)->localPoint = *arg2;
28083 }
28084
28085
28086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
28087   void * jresult ;
28088   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28089   Dali::Vector2 *result = 0 ;
28090
28091   arg1 = (Dali::LongPressGesture *)jarg1;
28092   result = (Dali::Vector2 *)& ((arg1)->localPoint);
28093   jresult = (void *)result;
28094   return jresult;
28095 }
28096
28097
28098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
28099   void * jresult ;
28100   Dali::WheelEvent *result = 0 ;
28101
28102   {
28103     try {
28104       result = (Dali::WheelEvent *)new Dali::WheelEvent();
28105     } catch (std::out_of_range& e) {
28106       {
28107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28108       };
28109     } catch (std::exception& e) {
28110       {
28111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28112       };
28113     } catch (...) {
28114       {
28115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28116       };
28117     }
28118   }
28119   jresult = (void *)result;
28120   return jresult;
28121 }
28122
28123
28124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
28125   void * jresult ;
28126   Dali::WheelEvent::Type arg1 ;
28127   int arg2 ;
28128   unsigned int arg3 ;
28129   Dali::Vector2 arg4 ;
28130   int arg5 ;
28131   unsigned int arg6 ;
28132   Dali::Vector2 *argp4 ;
28133   Dali::WheelEvent *result = 0 ;
28134
28135   arg1 = (Dali::WheelEvent::Type)jarg1;
28136   arg2 = (int)jarg2;
28137   arg3 = (unsigned int)jarg3;
28138   argp4 = (Dali::Vector2 *)jarg4;
28139   if (!argp4) {
28140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28141     return 0;
28142   }
28143   arg4 = *argp4;
28144   arg5 = (int)jarg5;
28145   arg6 = (unsigned int)jarg6;
28146   {
28147     try {
28148       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
28149     } catch (std::out_of_range& e) {
28150       {
28151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28152       };
28153     } catch (std::exception& e) {
28154       {
28155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28156       };
28157     } catch (...) {
28158       {
28159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28160       };
28161     }
28162   }
28163   jresult = (void *)result;
28164   return jresult;
28165 }
28166
28167
28168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
28169   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28170
28171   arg1 = (Dali::WheelEvent *)jarg1;
28172   {
28173     try {
28174       delete arg1;
28175     } catch (std::out_of_range& e) {
28176       {
28177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28178       };
28179     } catch (std::exception& e) {
28180       {
28181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28182       };
28183     } catch (...) {
28184       {
28185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28186       };
28187     }
28188   }
28189 }
28190
28191
28192 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
28193   unsigned int jresult ;
28194   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28195   bool result;
28196
28197   arg1 = (Dali::WheelEvent *)jarg1;
28198   {
28199     try {
28200       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
28201     } catch (std::out_of_range& e) {
28202       {
28203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28204       };
28205     } catch (std::exception& e) {
28206       {
28207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28208       };
28209     } catch (...) {
28210       {
28211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28212       };
28213     }
28214   }
28215   jresult = result;
28216   return jresult;
28217 }
28218
28219
28220 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
28221   unsigned int jresult ;
28222   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28223   bool result;
28224
28225   arg1 = (Dali::WheelEvent *)jarg1;
28226   {
28227     try {
28228       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
28229     } catch (std::out_of_range& e) {
28230       {
28231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28232       };
28233     } catch (std::exception& e) {
28234       {
28235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28236       };
28237     } catch (...) {
28238       {
28239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28240       };
28241     }
28242   }
28243   jresult = result;
28244   return jresult;
28245 }
28246
28247
28248 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
28249   unsigned int jresult ;
28250   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28251   bool result;
28252
28253   arg1 = (Dali::WheelEvent *)jarg1;
28254   {
28255     try {
28256       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
28257     } catch (std::out_of_range& e) {
28258       {
28259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28260       };
28261     } catch (std::exception& e) {
28262       {
28263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28264       };
28265     } catch (...) {
28266       {
28267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28268       };
28269     }
28270   }
28271   jresult = result;
28272   return jresult;
28273 }
28274
28275
28276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
28277   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28278   Dali::WheelEvent::Type arg2 ;
28279
28280   arg1 = (Dali::WheelEvent *)jarg1;
28281   arg2 = (Dali::WheelEvent::Type)jarg2;
28282   if (arg1) (arg1)->type = arg2;
28283 }
28284
28285
28286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
28287   int jresult ;
28288   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28289   Dali::WheelEvent::Type result;
28290
28291   arg1 = (Dali::WheelEvent *)jarg1;
28292   result = (Dali::WheelEvent::Type) ((arg1)->type);
28293   jresult = (int)result;
28294   return jresult;
28295 }
28296
28297
28298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
28299   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28300   int arg2 ;
28301
28302   arg1 = (Dali::WheelEvent *)jarg1;
28303   arg2 = (int)jarg2;
28304   if (arg1) (arg1)->direction = arg2;
28305 }
28306
28307
28308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
28309   int jresult ;
28310   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28311   int result;
28312
28313   arg1 = (Dali::WheelEvent *)jarg1;
28314   result = (int) ((arg1)->direction);
28315   jresult = result;
28316   return jresult;
28317 }
28318
28319
28320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
28321   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28322   unsigned int arg2 ;
28323
28324   arg1 = (Dali::WheelEvent *)jarg1;
28325   arg2 = (unsigned int)jarg2;
28326   if (arg1) (arg1)->modifiers = arg2;
28327 }
28328
28329
28330 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
28331   unsigned int jresult ;
28332   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28333   unsigned int result;
28334
28335   arg1 = (Dali::WheelEvent *)jarg1;
28336   result = (unsigned int) ((arg1)->modifiers);
28337   jresult = result;
28338   return jresult;
28339 }
28340
28341
28342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
28343   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28344   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28345
28346   arg1 = (Dali::WheelEvent *)jarg1;
28347   arg2 = (Dali::Vector2 *)jarg2;
28348   if (arg1) (arg1)->point = *arg2;
28349 }
28350
28351
28352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
28353   void * jresult ;
28354   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28355   Dali::Vector2 *result = 0 ;
28356
28357   arg1 = (Dali::WheelEvent *)jarg1;
28358   result = (Dali::Vector2 *)& ((arg1)->point);
28359   jresult = (void *)result;
28360   return jresult;
28361 }
28362
28363
28364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
28365   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28366   int arg2 ;
28367
28368   arg1 = (Dali::WheelEvent *)jarg1;
28369   arg2 = (int)jarg2;
28370   if (arg1) (arg1)->z = arg2;
28371 }
28372
28373
28374 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
28375   int jresult ;
28376   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28377   int result;
28378
28379   arg1 = (Dali::WheelEvent *)jarg1;
28380   result = (int) ((arg1)->z);
28381   jresult = result;
28382   return jresult;
28383 }
28384
28385
28386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
28387   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28388   unsigned int arg2 ;
28389
28390   arg1 = (Dali::WheelEvent *)jarg1;
28391   arg2 = (unsigned int)jarg2;
28392   if (arg1) (arg1)->timeStamp = arg2;
28393 }
28394
28395
28396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
28397   unsigned int jresult ;
28398   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28399   unsigned int result;
28400
28401   arg1 = (Dali::WheelEvent *)jarg1;
28402   result = (unsigned int) ((arg1)->timeStamp);
28403   jresult = result;
28404   return jresult;
28405 }
28406
28407
28408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
28409   int jresult ;
28410   int result;
28411
28412   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
28413   jresult = (int)result;
28414   return jresult;
28415 }
28416
28417
28418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
28419   int jresult ;
28420   int result;
28421
28422   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
28423   jresult = (int)result;
28424   return jresult;
28425 }
28426
28427
28428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
28429   int jresult ;
28430   int result;
28431
28432   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
28433   jresult = (int)result;
28434   return jresult;
28435 }
28436
28437
28438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
28439   int jresult ;
28440   int result;
28441
28442   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
28443   jresult = (int)result;
28444   return jresult;
28445 }
28446
28447
28448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
28449   int jresult ;
28450   int result;
28451
28452   result = (int)Dali::Actor::Property::ANCHOR_POINT;
28453   jresult = (int)result;
28454   return jresult;
28455 }
28456
28457
28458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
28459   int jresult ;
28460   int result;
28461
28462   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
28463   jresult = (int)result;
28464   return jresult;
28465 }
28466
28467
28468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
28469   int jresult ;
28470   int result;
28471
28472   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
28473   jresult = (int)result;
28474   return jresult;
28475 }
28476
28477
28478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
28479   int jresult ;
28480   int result;
28481
28482   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
28483   jresult = (int)result;
28484   return jresult;
28485 }
28486
28487
28488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
28489   int jresult ;
28490   int result;
28491
28492   result = (int)Dali::Actor::Property::SIZE;
28493   jresult = (int)result;
28494   return jresult;
28495 }
28496
28497
28498 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
28499   int jresult ;
28500   int result;
28501
28502   result = (int)Dali::Actor::Property::SIZE_WIDTH;
28503   jresult = (int)result;
28504   return jresult;
28505 }
28506
28507
28508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
28509   int jresult ;
28510   int result;
28511
28512   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
28513   jresult = (int)result;
28514   return jresult;
28515 }
28516
28517
28518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
28519   int jresult ;
28520   int result;
28521
28522   result = (int)Dali::Actor::Property::SIZE_DEPTH;
28523   jresult = (int)result;
28524   return jresult;
28525 }
28526
28527
28528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
28529   int jresult ;
28530   int result;
28531
28532   result = (int)Dali::Actor::Property::POSITION;
28533   jresult = (int)result;
28534   return jresult;
28535 }
28536
28537
28538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
28539   int jresult ;
28540   int result;
28541
28542   result = (int)Dali::Actor::Property::POSITION_X;
28543   jresult = (int)result;
28544   return jresult;
28545 }
28546
28547
28548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
28549   int jresult ;
28550   int result;
28551
28552   result = (int)Dali::Actor::Property::POSITION_Y;
28553   jresult = (int)result;
28554   return jresult;
28555 }
28556
28557
28558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
28559   int jresult ;
28560   int result;
28561
28562   result = (int)Dali::Actor::Property::POSITION_Z;
28563   jresult = (int)result;
28564   return jresult;
28565 }
28566
28567
28568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
28569   int jresult ;
28570   int result;
28571
28572   result = (int)Dali::Actor::Property::WORLD_POSITION;
28573   jresult = (int)result;
28574   return jresult;
28575 }
28576
28577
28578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
28579   int jresult ;
28580   int result;
28581
28582   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
28583   jresult = (int)result;
28584   return jresult;
28585 }
28586
28587
28588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
28589   int jresult ;
28590   int result;
28591
28592   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
28593   jresult = (int)result;
28594   return jresult;
28595 }
28596
28597
28598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
28599   int jresult ;
28600   int result;
28601
28602   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
28603   jresult = (int)result;
28604   return jresult;
28605 }
28606
28607
28608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
28609   int jresult ;
28610   int result;
28611
28612   result = (int)Dali::Actor::Property::ORIENTATION;
28613   jresult = (int)result;
28614   return jresult;
28615 }
28616
28617
28618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
28619   int jresult ;
28620   int result;
28621
28622   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
28623   jresult = (int)result;
28624   return jresult;
28625 }
28626
28627
28628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
28629   int jresult ;
28630   int result;
28631
28632   result = (int)Dali::Actor::Property::SCALE;
28633   jresult = (int)result;
28634   return jresult;
28635 }
28636
28637
28638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
28639   int jresult ;
28640   int result;
28641
28642   result = (int)Dali::Actor::Property::SCALE_X;
28643   jresult = (int)result;
28644   return jresult;
28645 }
28646
28647
28648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
28649   int jresult ;
28650   int result;
28651
28652   result = (int)Dali::Actor::Property::SCALE_Y;
28653   jresult = (int)result;
28654   return jresult;
28655 }
28656
28657
28658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
28659   int jresult ;
28660   int result;
28661
28662   result = (int)Dali::Actor::Property::SCALE_Z;
28663   jresult = (int)result;
28664   return jresult;
28665 }
28666
28667
28668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
28669   int jresult ;
28670   int result;
28671
28672   result = (int)Dali::Actor::Property::WORLD_SCALE;
28673   jresult = (int)result;
28674   return jresult;
28675 }
28676
28677
28678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
28679   int jresult ;
28680   int result;
28681
28682   result = (int)Dali::Actor::Property::VISIBLE;
28683   jresult = (int)result;
28684   return jresult;
28685 }
28686
28687
28688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
28689   int jresult ;
28690   int result;
28691
28692   result = (int)Dali::Actor::Property::COLOR;
28693   jresult = (int)result;
28694   return jresult;
28695 }
28696
28697
28698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
28699   int jresult ;
28700   int result;
28701
28702   result = (int)Dali::Actor::Property::COLOR_RED;
28703   jresult = (int)result;
28704   return jresult;
28705 }
28706
28707
28708 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
28709   int jresult ;
28710   int result;
28711
28712   result = (int)Dali::Actor::Property::COLOR_GREEN;
28713   jresult = (int)result;
28714   return jresult;
28715 }
28716
28717
28718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
28719   int jresult ;
28720   int result;
28721
28722   result = (int)Dali::Actor::Property::COLOR_BLUE;
28723   jresult = (int)result;
28724   return jresult;
28725 }
28726
28727
28728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
28729   int jresult ;
28730   int result;
28731
28732   result = (int)Dali::Actor::Property::COLOR_ALPHA;
28733   jresult = (int)result;
28734   return jresult;
28735 }
28736
28737
28738 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
28739   int jresult ;
28740   int result;
28741
28742   result = (int)Dali::Actor::Property::WORLD_COLOR;
28743   jresult = (int)result;
28744   return jresult;
28745 }
28746
28747
28748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
28749   int jresult ;
28750   int result;
28751
28752   result = (int)Dali::Actor::Property::WORLD_MATRIX;
28753   jresult = (int)result;
28754   return jresult;
28755 }
28756
28757
28758 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
28759   int jresult ;
28760   int result;
28761
28762   result = (int)Dali::Actor::Property::NAME;
28763   jresult = (int)result;
28764   return jresult;
28765 }
28766
28767
28768 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
28769   int jresult ;
28770   int result;
28771
28772   result = (int)Dali::Actor::Property::SENSITIVE;
28773   jresult = (int)result;
28774   return jresult;
28775 }
28776
28777
28778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
28779   int jresult ;
28780   int result;
28781
28782   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
28783   jresult = (int)result;
28784   return jresult;
28785 }
28786
28787
28788 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
28789   int jresult ;
28790   int result;
28791
28792   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
28793   jresult = (int)result;
28794   return jresult;
28795 }
28796
28797
28798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
28799   int jresult ;
28800   int result;
28801
28802   result = (int)Dali::Actor::Property::INHERIT_SCALE;
28803   jresult = (int)result;
28804   return jresult;
28805 }
28806
28807
28808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
28809   int jresult ;
28810   int result;
28811
28812   result = (int)Dali::Actor::Property::COLOR_MODE;
28813   jresult = (int)result;
28814   return jresult;
28815 }
28816
28817
28818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
28819   int jresult ;
28820   int result;
28821
28822   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
28823   jresult = (int)result;
28824   return jresult;
28825 }
28826
28827
28828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
28829   int jresult ;
28830   int result;
28831
28832   result = (int)Dali::Actor::Property::DRAW_MODE;
28833   jresult = (int)result;
28834   return jresult;
28835 }
28836
28837
28838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
28839   int jresult ;
28840   int result;
28841
28842   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
28843   jresult = (int)result;
28844   return jresult;
28845 }
28846
28847
28848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
28849   int jresult ;
28850   int result;
28851
28852   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
28853   jresult = (int)result;
28854   return jresult;
28855 }
28856
28857
28858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
28859   int jresult ;
28860   int result;
28861
28862   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
28863   jresult = (int)result;
28864   return jresult;
28865 }
28866
28867
28868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
28869   int jresult ;
28870   int result;
28871
28872   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
28873   jresult = (int)result;
28874   return jresult;
28875 }
28876
28877
28878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
28879   int jresult ;
28880   int result;
28881
28882   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
28883   jresult = (int)result;
28884   return jresult;
28885 }
28886
28887
28888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
28889   int jresult ;
28890   int result;
28891
28892   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
28893   jresult = (int)result;
28894   return jresult;
28895 }
28896
28897
28898 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
28899   int jresult ;
28900   int result;
28901
28902   result = (int)Dali::Actor::Property::PADDING;
28903   jresult = (int)result;
28904   return jresult;
28905 }
28906
28907
28908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
28909   int jresult ;
28910   int result;
28911
28912   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
28913   jresult = (int)result;
28914   return jresult;
28915 }
28916
28917
28918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
28919   int jresult ;
28920   int result;
28921
28922   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
28923   jresult = (int)result;
28924   return jresult;
28925 }
28926
28927
28928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
28929   int jresult ;
28930   int result;
28931
28932   result = (int)Dali::Actor::Property::INHERIT_POSITION;
28933   jresult = (int)result;
28934   return jresult;
28935 }
28936
28937
28938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
28939   int jresult ;
28940   int result;
28941
28942   result = (int)Dali::Actor::Property::CLIPPING_MODE;
28943   jresult = (int)result;
28944   return jresult;
28945 }
28946
28947
28948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
28949   void * jresult ;
28950   Dali::Actor::Property *result = 0 ;
28951
28952   {
28953     try {
28954       result = (Dali::Actor::Property *)new Dali::Actor::Property();
28955     } catch (std::out_of_range& e) {
28956       {
28957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28958       };
28959     } catch (std::exception& e) {
28960       {
28961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28962       };
28963     } catch (...) {
28964       {
28965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28966       };
28967     }
28968   }
28969   jresult = (void *)result;
28970   return jresult;
28971 }
28972
28973
28974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
28975   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
28976
28977   arg1 = (Dali::Actor::Property *)jarg1;
28978   {
28979     try {
28980       delete arg1;
28981     } catch (std::out_of_range& e) {
28982       {
28983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28984       };
28985     } catch (std::exception& e) {
28986       {
28987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28988       };
28989     } catch (...) {
28990       {
28991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28992       };
28993     }
28994   }
28995 }
28996
28997
28998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
28999   void * jresult ;
29000   Dali::Actor *result = 0 ;
29001
29002   {
29003     try {
29004       result = (Dali::Actor *)new Dali::Actor();
29005     } catch (std::out_of_range& e) {
29006       {
29007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29008       };
29009     } catch (std::exception& e) {
29010       {
29011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29012       };
29013     } catch (...) {
29014       {
29015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29016       };
29017     }
29018   }
29019   jresult = (void *)result;
29020   return jresult;
29021 }
29022
29023
29024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
29025   void * jresult ;
29026   Dali::Actor result;
29027
29028   {
29029     try {
29030       result = Dali::Actor::New();
29031     } catch (std::out_of_range& e) {
29032       {
29033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29034       };
29035     } catch (std::exception& e) {
29036       {
29037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29038       };
29039     } catch (...) {
29040       {
29041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29042       };
29043     }
29044   }
29045   jresult = new Dali::Actor((const Dali::Actor &)result);
29046   return jresult;
29047 }
29048
29049
29050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
29051   void * jresult ;
29052   Dali::BaseHandle arg1 ;
29053   Dali::BaseHandle *argp1 ;
29054   Dali::Actor result;
29055
29056   argp1 = (Dali::BaseHandle *)jarg1;
29057   if (!argp1) {
29058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
29059     return 0;
29060   }
29061   arg1 = *argp1;
29062   {
29063     try {
29064       result = Dali::Actor::DownCast(arg1);
29065     } catch (std::out_of_range& e) {
29066       {
29067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29068       };
29069     } catch (std::exception& e) {
29070       {
29071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29072       };
29073     } catch (...) {
29074       {
29075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29076       };
29077     }
29078   }
29079   jresult = new Dali::Actor((const Dali::Actor &)result);
29080   return jresult;
29081 }
29082
29083
29084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
29085   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29086
29087   arg1 = (Dali::Actor *)jarg1;
29088   {
29089     try {
29090       delete arg1;
29091     } catch (std::out_of_range& e) {
29092       {
29093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29094       };
29095     } catch (std::exception& e) {
29096       {
29097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29098       };
29099     } catch (...) {
29100       {
29101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29102       };
29103     }
29104   }
29105 }
29106
29107
29108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
29109   void * jresult ;
29110   Dali::Actor *arg1 = 0 ;
29111   Dali::Actor *result = 0 ;
29112
29113   arg1 = (Dali::Actor *)jarg1;
29114   if (!arg1) {
29115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29116     return 0;
29117   }
29118   {
29119     try {
29120       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
29121     } catch (std::out_of_range& e) {
29122       {
29123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29124       };
29125     } catch (std::exception& e) {
29126       {
29127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29128       };
29129     } catch (...) {
29130       {
29131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29132       };
29133     }
29134   }
29135   jresult = (void *)result;
29136   return jresult;
29137 }
29138
29139
29140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
29141   void * jresult ;
29142   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29143   Dali::Actor *arg2 = 0 ;
29144   Dali::Actor *result = 0 ;
29145
29146   arg1 = (Dali::Actor *)jarg1;
29147   arg2 = (Dali::Actor *)jarg2;
29148   if (!arg2) {
29149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29150     return 0;
29151   }
29152   {
29153     try {
29154       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
29155     } catch (std::out_of_range& e) {
29156       {
29157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29158       };
29159     } catch (std::exception& e) {
29160       {
29161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29162       };
29163     } catch (...) {
29164       {
29165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29166       };
29167     }
29168   }
29169   jresult = (void *)result;
29170   return jresult;
29171 }
29172
29173
29174 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
29175   char * jresult ;
29176   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29177   std::string *result = 0 ;
29178
29179   arg1 = (Dali::Actor *)jarg1;
29180   {
29181     try {
29182       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
29183     } catch (std::out_of_range& e) {
29184       {
29185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29186       };
29187     } catch (std::exception& e) {
29188       {
29189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29190       };
29191     } catch (...) {
29192       {
29193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29194       };
29195     }
29196   }
29197   jresult = SWIG_csharp_string_callback(result->c_str());
29198   return jresult;
29199 }
29200
29201
29202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
29203   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29204   std::string *arg2 = 0 ;
29205
29206   arg1 = (Dali::Actor *)jarg1;
29207   if (!jarg2) {
29208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29209     return ;
29210   }
29211   std::string arg2_str(jarg2);
29212   arg2 = &arg2_str;
29213   {
29214     try {
29215       (arg1)->SetName((std::string const &)*arg2);
29216     } catch (std::out_of_range& e) {
29217       {
29218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29219       };
29220     } catch (std::exception& e) {
29221       {
29222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29223       };
29224     } catch (...) {
29225       {
29226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29227       };
29228     }
29229   }
29230
29231   //argout typemap for const std::string&
29232
29233 }
29234
29235
29236 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
29237   unsigned int jresult ;
29238   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29239   unsigned int result;
29240
29241   arg1 = (Dali::Actor *)jarg1;
29242   {
29243     try {
29244       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
29245     } catch (std::out_of_range& e) {
29246       {
29247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29248       };
29249     } catch (std::exception& e) {
29250       {
29251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29252       };
29253     } catch (...) {
29254       {
29255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29256       };
29257     }
29258   }
29259   jresult = result;
29260   return jresult;
29261 }
29262
29263
29264 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
29265   unsigned int jresult ;
29266   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29267   bool result;
29268
29269   arg1 = (Dali::Actor *)jarg1;
29270   {
29271     try {
29272       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
29273     } catch (std::out_of_range& e) {
29274       {
29275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29276       };
29277     } catch (std::exception& e) {
29278       {
29279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29280       };
29281     } catch (...) {
29282       {
29283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29284       };
29285     }
29286   }
29287   jresult = result;
29288   return jresult;
29289 }
29290
29291
29292 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
29293   unsigned int jresult ;
29294   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29295   bool result;
29296
29297   arg1 = (Dali::Actor *)jarg1;
29298   {
29299     try {
29300       result = (bool)((Dali::Actor const *)arg1)->OnStage();
29301     } catch (std::out_of_range& e) {
29302       {
29303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29304       };
29305     } catch (std::exception& e) {
29306       {
29307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29308       };
29309     } catch (...) {
29310       {
29311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29312       };
29313     }
29314   }
29315   jresult = result;
29316   return jresult;
29317 }
29318
29319
29320 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
29321   unsigned int jresult ;
29322   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29323   bool result;
29324
29325   arg1 = (Dali::Actor *)jarg1;
29326   {
29327     try {
29328       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
29329     } catch (std::out_of_range& e) {
29330       {
29331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29332       };
29333     } catch (std::exception& e) {
29334       {
29335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29336       };
29337     } catch (...) {
29338       {
29339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29340       };
29341     }
29342   }
29343   jresult = result;
29344   return jresult;
29345 }
29346
29347
29348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
29349   void * jresult ;
29350   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29351   Dali::Layer result;
29352
29353   arg1 = (Dali::Actor *)jarg1;
29354   {
29355     try {
29356       result = (arg1)->GetLayer();
29357     } catch (std::out_of_range& e) {
29358       {
29359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29360       };
29361     } catch (std::exception& e) {
29362       {
29363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29364       };
29365     } catch (...) {
29366       {
29367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29368       };
29369     }
29370   }
29371   jresult = new Dali::Layer((const Dali::Layer &)result);
29372   return jresult;
29373 }
29374
29375
29376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
29377   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29378   Dali::Actor arg2 ;
29379   Dali::Actor *argp2 ;
29380
29381   arg1 = (Dali::Actor *)jarg1;
29382   argp2 = (Dali::Actor *)jarg2;
29383   if (!argp2) {
29384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29385     return ;
29386   }
29387   arg2 = *argp2;
29388   {
29389     try {
29390       (arg1)->Add(arg2);
29391     } catch (std::out_of_range& e) {
29392       {
29393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29394       };
29395     } catch (std::exception& e) {
29396       {
29397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29398       };
29399     } catch (...) {
29400       {
29401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29402       };
29403     }
29404   }
29405 }
29406
29407
29408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
29409   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29410   Dali::Actor arg2 ;
29411   Dali::Actor *argp2 ;
29412
29413   arg1 = (Dali::Actor *)jarg1;
29414   argp2 = (Dali::Actor *)jarg2;
29415   if (!argp2) {
29416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29417     return ;
29418   }
29419   arg2 = *argp2;
29420   {
29421     try {
29422       (arg1)->Remove(arg2);
29423     } catch (std::out_of_range& e) {
29424       {
29425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29426       };
29427     } catch (std::exception& e) {
29428       {
29429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29430       };
29431     } catch (...) {
29432       {
29433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29434       };
29435     }
29436   }
29437 }
29438
29439
29440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
29441   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29442
29443   arg1 = (Dali::Actor *)jarg1;
29444   {
29445     try {
29446       (arg1)->Unparent();
29447     } catch (std::out_of_range& e) {
29448       {
29449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29450       };
29451     } catch (std::exception& e) {
29452       {
29453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29454       };
29455     } catch (...) {
29456       {
29457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29458       };
29459     }
29460   }
29461 }
29462
29463
29464 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
29465   unsigned int jresult ;
29466   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29467   unsigned int result;
29468
29469   arg1 = (Dali::Actor *)jarg1;
29470   {
29471     try {
29472       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
29473     } catch (std::out_of_range& e) {
29474       {
29475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29476       };
29477     } catch (std::exception& e) {
29478       {
29479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29480       };
29481     } catch (...) {
29482       {
29483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29484       };
29485     }
29486   }
29487   jresult = result;
29488   return jresult;
29489 }
29490
29491
29492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
29493   void * jresult ;
29494   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29495   unsigned int arg2 ;
29496   Dali::Actor result;
29497
29498   arg1 = (Dali::Actor *)jarg1;
29499   arg2 = (unsigned int)jarg2;
29500   {
29501     try {
29502       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
29503     } catch (std::out_of_range& e) {
29504       {
29505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29506       };
29507     } catch (std::exception& e) {
29508       {
29509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29510       };
29511     } catch (...) {
29512       {
29513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29514       };
29515     }
29516   }
29517   jresult = new Dali::Actor((const Dali::Actor &)result);
29518   return jresult;
29519 }
29520
29521
29522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
29523   void * jresult ;
29524   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29525   std::string *arg2 = 0 ;
29526   Dali::Actor result;
29527
29528   arg1 = (Dali::Actor *)jarg1;
29529   if (!jarg2) {
29530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29531     return 0;
29532   }
29533   std::string arg2_str(jarg2);
29534   arg2 = &arg2_str;
29535   {
29536     try {
29537       result = (arg1)->FindChildByName((std::string const &)*arg2);
29538     } catch (std::out_of_range& e) {
29539       {
29540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29541       };
29542     } catch (std::exception& e) {
29543       {
29544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29545       };
29546     } catch (...) {
29547       {
29548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29549       };
29550     }
29551   }
29552   jresult = new Dali::Actor((const Dali::Actor &)result);
29553
29554   //argout typemap for const std::string&
29555
29556   return jresult;
29557 }
29558
29559
29560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
29561   void * jresult ;
29562   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29563   unsigned int arg2 ;
29564   Dali::Actor result;
29565
29566   arg1 = (Dali::Actor *)jarg1;
29567   arg2 = (unsigned int)jarg2;
29568   {
29569     try {
29570       result = (arg1)->FindChildById(arg2);
29571     } catch (std::out_of_range& e) {
29572       {
29573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29574       };
29575     } catch (std::exception& e) {
29576       {
29577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29578       };
29579     } catch (...) {
29580       {
29581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29582       };
29583     }
29584   }
29585   jresult = new Dali::Actor((const Dali::Actor &)result);
29586   return jresult;
29587 }
29588
29589
29590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
29591   void * jresult ;
29592   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29593   Dali::Actor result;
29594
29595   arg1 = (Dali::Actor *)jarg1;
29596   {
29597     try {
29598       result = ((Dali::Actor const *)arg1)->GetParent();
29599     } catch (std::out_of_range& e) {
29600       {
29601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29602       };
29603     } catch (std::exception& e) {
29604       {
29605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29606       };
29607     } catch (...) {
29608       {
29609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29610       };
29611     }
29612   }
29613   jresult = new Dali::Actor((const Dali::Actor &)result);
29614   return jresult;
29615 }
29616
29617
29618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
29619   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29620   Dali::Vector3 *arg2 = 0 ;
29621
29622   arg1 = (Dali::Actor *)jarg1;
29623   arg2 = (Dali::Vector3 *)jarg2;
29624   if (!arg2) {
29625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29626     return ;
29627   }
29628   {
29629     try {
29630       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
29631     } catch (std::out_of_range& e) {
29632       {
29633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29634       };
29635     } catch (std::exception& e) {
29636       {
29637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29638       };
29639     } catch (...) {
29640       {
29641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29642       };
29643     }
29644   }
29645 }
29646
29647
29648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
29649   void * jresult ;
29650   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29651   Dali::Vector3 result;
29652
29653   arg1 = (Dali::Actor *)jarg1;
29654   {
29655     try {
29656       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
29657     } catch (std::out_of_range& e) {
29658       {
29659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29660       };
29661     } catch (std::exception& e) {
29662       {
29663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29664       };
29665     } catch (...) {
29666       {
29667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29668       };
29669     }
29670   }
29671   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29672   return jresult;
29673 }
29674
29675
29676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
29677   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29678   Dali::Vector3 *arg2 = 0 ;
29679
29680   arg1 = (Dali::Actor *)jarg1;
29681   arg2 = (Dali::Vector3 *)jarg2;
29682   if (!arg2) {
29683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29684     return ;
29685   }
29686   {
29687     try {
29688       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
29689     } catch (std::out_of_range& e) {
29690       {
29691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29692       };
29693     } catch (std::exception& e) {
29694       {
29695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29696       };
29697     } catch (...) {
29698       {
29699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29700       };
29701     }
29702   }
29703 }
29704
29705
29706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
29707   void * jresult ;
29708   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29709   Dali::Vector3 result;
29710
29711   arg1 = (Dali::Actor *)jarg1;
29712   {
29713     try {
29714       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
29715     } catch (std::out_of_range& e) {
29716       {
29717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29718       };
29719     } catch (std::exception& e) {
29720       {
29721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29722       };
29723     } catch (...) {
29724       {
29725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29726       };
29727     }
29728   }
29729   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29730   return jresult;
29731 }
29732
29733
29734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
29735   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29736   float arg2 ;
29737   float arg3 ;
29738
29739   arg1 = (Dali::Actor *)jarg1;
29740   arg2 = (float)jarg2;
29741   arg3 = (float)jarg3;
29742   {
29743     try {
29744       (arg1)->SetSize(arg2,arg3);
29745     } catch (std::out_of_range& e) {
29746       {
29747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29748       };
29749     } catch (std::exception& e) {
29750       {
29751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29752       };
29753     } catch (...) {
29754       {
29755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29756       };
29757     }
29758   }
29759 }
29760
29761
29762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
29763   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29764   float arg2 ;
29765   float arg3 ;
29766   float arg4 ;
29767
29768   arg1 = (Dali::Actor *)jarg1;
29769   arg2 = (float)jarg2;
29770   arg3 = (float)jarg3;
29771   arg4 = (float)jarg4;
29772   {
29773     try {
29774       (arg1)->SetSize(arg2,arg3,arg4);
29775     } catch (std::out_of_range& e) {
29776       {
29777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29778       };
29779     } catch (std::exception& e) {
29780       {
29781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29782       };
29783     } catch (...) {
29784       {
29785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29786       };
29787     }
29788   }
29789 }
29790
29791
29792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
29793   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29794   Dali::Vector2 *arg2 = 0 ;
29795
29796   arg1 = (Dali::Actor *)jarg1;
29797   arg2 = (Dali::Vector2 *)jarg2;
29798   if (!arg2) {
29799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
29800     return ;
29801   }
29802   {
29803     try {
29804       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
29805     } catch (std::out_of_range& e) {
29806       {
29807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29808       };
29809     } catch (std::exception& e) {
29810       {
29811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29812       };
29813     } catch (...) {
29814       {
29815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29816       };
29817     }
29818   }
29819 }
29820
29821
29822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
29823   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29824   Dali::Vector3 *arg2 = 0 ;
29825
29826   arg1 = (Dali::Actor *)jarg1;
29827   arg2 = (Dali::Vector3 *)jarg2;
29828   if (!arg2) {
29829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29830     return ;
29831   }
29832   {
29833     try {
29834       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
29835     } catch (std::out_of_range& e) {
29836       {
29837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29838       };
29839     } catch (std::exception& e) {
29840       {
29841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29842       };
29843     } catch (...) {
29844       {
29845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29846       };
29847     }
29848   }
29849 }
29850
29851
29852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
29853   void * jresult ;
29854   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29855   Dali::Vector3 result;
29856
29857   arg1 = (Dali::Actor *)jarg1;
29858   {
29859     try {
29860       result = ((Dali::Actor const *)arg1)->GetTargetSize();
29861     } catch (std::out_of_range& e) {
29862       {
29863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29864       };
29865     } catch (std::exception& e) {
29866       {
29867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29868       };
29869     } catch (...) {
29870       {
29871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29872       };
29873     }
29874   }
29875   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29876   return jresult;
29877 }
29878
29879
29880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
29881   void * jresult ;
29882   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29883   Dali::Vector3 result;
29884
29885   arg1 = (Dali::Actor *)jarg1;
29886   {
29887     try {
29888       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
29889     } catch (std::out_of_range& e) {
29890       {
29891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29892       };
29893     } catch (std::exception& e) {
29894       {
29895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29896       };
29897     } catch (...) {
29898       {
29899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29900       };
29901     }
29902   }
29903   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29904   return jresult;
29905 }
29906
29907
29908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
29909   void * jresult ;
29910   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29911   Dali::Vector3 result;
29912
29913   arg1 = (Dali::Actor *)jarg1;
29914   {
29915     try {
29916       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
29917     } catch (std::out_of_range& e) {
29918       {
29919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29920       };
29921     } catch (std::exception& e) {
29922       {
29923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29924       };
29925     } catch (...) {
29926       {
29927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29928       };
29929     }
29930   }
29931   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29932   return jresult;
29933 }
29934
29935
29936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
29937   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29938   float arg2 ;
29939   float arg3 ;
29940
29941   arg1 = (Dali::Actor *)jarg1;
29942   arg2 = (float)jarg2;
29943   arg3 = (float)jarg3;
29944   {
29945     try {
29946       (arg1)->SetPosition(arg2,arg3);
29947     } catch (std::out_of_range& e) {
29948       {
29949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29950       };
29951     } catch (std::exception& e) {
29952       {
29953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29954       };
29955     } catch (...) {
29956       {
29957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29958       };
29959     }
29960   }
29961 }
29962
29963
29964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
29965   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29966   float arg2 ;
29967   float arg3 ;
29968   float arg4 ;
29969
29970   arg1 = (Dali::Actor *)jarg1;
29971   arg2 = (float)jarg2;
29972   arg3 = (float)jarg3;
29973   arg4 = (float)jarg4;
29974   {
29975     try {
29976       (arg1)->SetPosition(arg2,arg3,arg4);
29977     } catch (std::out_of_range& e) {
29978       {
29979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29980       };
29981     } catch (std::exception& e) {
29982       {
29983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29984       };
29985     } catch (...) {
29986       {
29987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29988       };
29989     }
29990   }
29991 }
29992
29993
29994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
29995   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29996   Dali::Vector3 *arg2 = 0 ;
29997
29998   arg1 = (Dali::Actor *)jarg1;
29999   arg2 = (Dali::Vector3 *)jarg2;
30000   if (!arg2) {
30001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30002     return ;
30003   }
30004   {
30005     try {
30006       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
30007     } catch (std::out_of_range& e) {
30008       {
30009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30010       };
30011     } catch (std::exception& e) {
30012       {
30013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30014       };
30015     } catch (...) {
30016       {
30017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30018       };
30019     }
30020   }
30021 }
30022
30023
30024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
30025   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30026   float arg2 ;
30027
30028   arg1 = (Dali::Actor *)jarg1;
30029   arg2 = (float)jarg2;
30030   {
30031     try {
30032       (arg1)->SetX(arg2);
30033     } catch (std::out_of_range& e) {
30034       {
30035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30036       };
30037     } catch (std::exception& e) {
30038       {
30039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30040       };
30041     } catch (...) {
30042       {
30043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30044       };
30045     }
30046   }
30047 }
30048
30049
30050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
30051   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30052   float arg2 ;
30053
30054   arg1 = (Dali::Actor *)jarg1;
30055   arg2 = (float)jarg2;
30056   {
30057     try {
30058       (arg1)->SetY(arg2);
30059     } catch (std::out_of_range& e) {
30060       {
30061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30062       };
30063     } catch (std::exception& e) {
30064       {
30065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30066       };
30067     } catch (...) {
30068       {
30069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30070       };
30071     }
30072   }
30073 }
30074
30075
30076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
30077   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30078   float arg2 ;
30079
30080   arg1 = (Dali::Actor *)jarg1;
30081   arg2 = (float)jarg2;
30082   {
30083     try {
30084       (arg1)->SetZ(arg2);
30085     } catch (std::out_of_range& e) {
30086       {
30087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30088       };
30089     } catch (std::exception& e) {
30090       {
30091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30092       };
30093     } catch (...) {
30094       {
30095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30096       };
30097     }
30098   }
30099 }
30100
30101
30102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
30103   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30104   Dali::Vector3 *arg2 = 0 ;
30105
30106   arg1 = (Dali::Actor *)jarg1;
30107   arg2 = (Dali::Vector3 *)jarg2;
30108   if (!arg2) {
30109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30110     return ;
30111   }
30112   {
30113     try {
30114       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
30115     } catch (std::out_of_range& e) {
30116       {
30117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30118       };
30119     } catch (std::exception& e) {
30120       {
30121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30122       };
30123     } catch (...) {
30124       {
30125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30126       };
30127     }
30128   }
30129 }
30130
30131
30132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
30133   void * jresult ;
30134   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30135   Dali::Vector3 result;
30136
30137   arg1 = (Dali::Actor *)jarg1;
30138   {
30139     try {
30140       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
30141     } catch (std::out_of_range& e) {
30142       {
30143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30144       };
30145     } catch (std::exception& e) {
30146       {
30147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30148       };
30149     } catch (...) {
30150       {
30151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30152       };
30153     }
30154   }
30155   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30156   return jresult;
30157 }
30158
30159
30160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
30161   void * jresult ;
30162   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30163   Dali::Vector3 result;
30164
30165   arg1 = (Dali::Actor *)jarg1;
30166   {
30167     try {
30168       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
30169     } catch (std::out_of_range& e) {
30170       {
30171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30172       };
30173     } catch (std::exception& e) {
30174       {
30175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30176       };
30177     } catch (...) {
30178       {
30179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30180       };
30181     }
30182   }
30183   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30184   return jresult;
30185 }
30186
30187
30188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
30189   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30190   bool arg2 ;
30191
30192   arg1 = (Dali::Actor *)jarg1;
30193   arg2 = jarg2 ? true : false;
30194   {
30195     try {
30196       (arg1)->SetInheritPosition(arg2);
30197     } catch (std::out_of_range& e) {
30198       {
30199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30200       };
30201     } catch (std::exception& e) {
30202       {
30203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30204       };
30205     } catch (...) {
30206       {
30207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30208       };
30209     }
30210   }
30211 }
30212
30213
30214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
30215   int jresult ;
30216   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30217   Dali::PositionInheritanceMode result;
30218
30219   arg1 = (Dali::Actor *)jarg1;
30220   {
30221     try {
30222       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
30223     } catch (std::out_of_range& e) {
30224       {
30225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30226       };
30227     } catch (std::exception& e) {
30228       {
30229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30230       };
30231     } catch (...) {
30232       {
30233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30234       };
30235     }
30236   }
30237   jresult = (int)result;
30238   return jresult;
30239 }
30240
30241
30242 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
30243   unsigned int jresult ;
30244   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30245   bool result;
30246
30247   arg1 = (Dali::Actor *)jarg1;
30248   {
30249     try {
30250       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
30251     } catch (std::out_of_range& e) {
30252       {
30253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30254       };
30255     } catch (std::exception& e) {
30256       {
30257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30258       };
30259     } catch (...) {
30260       {
30261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30262       };
30263     }
30264   }
30265   jresult = result;
30266   return jresult;
30267 }
30268
30269
30270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30271   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30272   Dali::Degree *arg2 = 0 ;
30273   Dali::Vector3 *arg3 = 0 ;
30274
30275   arg1 = (Dali::Actor *)jarg1;
30276   arg2 = (Dali::Degree *)jarg2;
30277   if (!arg2) {
30278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30279     return ;
30280   }
30281   arg3 = (Dali::Vector3 *)jarg3;
30282   if (!arg3) {
30283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30284     return ;
30285   }
30286   {
30287     try {
30288       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30289     } catch (std::out_of_range& e) {
30290       {
30291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30292       };
30293     } catch (std::exception& e) {
30294       {
30295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30296       };
30297     } catch (...) {
30298       {
30299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30300       };
30301     }
30302   }
30303 }
30304
30305
30306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30307   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30308   Dali::Radian *arg2 = 0 ;
30309   Dali::Vector3 *arg3 = 0 ;
30310
30311   arg1 = (Dali::Actor *)jarg1;
30312   arg2 = (Dali::Radian *)jarg2;
30313   if (!arg2) {
30314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30315     return ;
30316   }
30317   arg3 = (Dali::Vector3 *)jarg3;
30318   if (!arg3) {
30319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30320     return ;
30321   }
30322   {
30323     try {
30324       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30325     } catch (std::out_of_range& e) {
30326       {
30327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30328       };
30329     } catch (std::exception& e) {
30330       {
30331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30332       };
30333     } catch (...) {
30334       {
30335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30336       };
30337     }
30338   }
30339 }
30340
30341
30342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
30343   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30344   Dali::Quaternion *arg2 = 0 ;
30345
30346   arg1 = (Dali::Actor *)jarg1;
30347   arg2 = (Dali::Quaternion *)jarg2;
30348   if (!arg2) {
30349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30350     return ;
30351   }
30352   {
30353     try {
30354       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
30355     } catch (std::out_of_range& e) {
30356       {
30357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30358       };
30359     } catch (std::exception& e) {
30360       {
30361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30362       };
30363     } catch (...) {
30364       {
30365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30366       };
30367     }
30368   }
30369 }
30370
30371
30372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30373   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30374   Dali::Degree *arg2 = 0 ;
30375   Dali::Vector3 *arg3 = 0 ;
30376
30377   arg1 = (Dali::Actor *)jarg1;
30378   arg2 = (Dali::Degree *)jarg2;
30379   if (!arg2) {
30380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30381     return ;
30382   }
30383   arg3 = (Dali::Vector3 *)jarg3;
30384   if (!arg3) {
30385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30386     return ;
30387   }
30388   {
30389     try {
30390       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30391     } catch (std::out_of_range& e) {
30392       {
30393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30394       };
30395     } catch (std::exception& e) {
30396       {
30397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30398       };
30399     } catch (...) {
30400       {
30401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30402       };
30403     }
30404   }
30405 }
30406
30407
30408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30409   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30410   Dali::Radian *arg2 = 0 ;
30411   Dali::Vector3 *arg3 = 0 ;
30412
30413   arg1 = (Dali::Actor *)jarg1;
30414   arg2 = (Dali::Radian *)jarg2;
30415   if (!arg2) {
30416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30417     return ;
30418   }
30419   arg3 = (Dali::Vector3 *)jarg3;
30420   if (!arg3) {
30421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30422     return ;
30423   }
30424   {
30425     try {
30426       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30427     } catch (std::out_of_range& e) {
30428       {
30429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30430       };
30431     } catch (std::exception& e) {
30432       {
30433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30434       };
30435     } catch (...) {
30436       {
30437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30438       };
30439     }
30440   }
30441 }
30442
30443
30444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
30445   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30446   Dali::Quaternion *arg2 = 0 ;
30447
30448   arg1 = (Dali::Actor *)jarg1;
30449   arg2 = (Dali::Quaternion *)jarg2;
30450   if (!arg2) {
30451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30452     return ;
30453   }
30454   {
30455     try {
30456       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
30457     } catch (std::out_of_range& e) {
30458       {
30459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30460       };
30461     } catch (std::exception& e) {
30462       {
30463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30464       };
30465     } catch (...) {
30466       {
30467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30468       };
30469     }
30470   }
30471 }
30472
30473
30474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
30475   void * jresult ;
30476   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30477   Dali::Quaternion result;
30478
30479   arg1 = (Dali::Actor *)jarg1;
30480   {
30481     try {
30482       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
30483     } catch (std::out_of_range& e) {
30484       {
30485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30486       };
30487     } catch (std::exception& e) {
30488       {
30489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30490       };
30491     } catch (...) {
30492       {
30493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30494       };
30495     }
30496   }
30497   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30498   return jresult;
30499 }
30500
30501
30502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
30503   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30504   bool arg2 ;
30505
30506   arg1 = (Dali::Actor *)jarg1;
30507   arg2 = jarg2 ? true : false;
30508   {
30509     try {
30510       (arg1)->SetInheritOrientation(arg2);
30511     } catch (std::out_of_range& e) {
30512       {
30513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30514       };
30515     } catch (std::exception& e) {
30516       {
30517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30518       };
30519     } catch (...) {
30520       {
30521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30522       };
30523     }
30524   }
30525 }
30526
30527
30528 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
30529   unsigned int jresult ;
30530   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30531   bool result;
30532
30533   arg1 = (Dali::Actor *)jarg1;
30534   {
30535     try {
30536       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
30537     } catch (std::out_of_range& e) {
30538       {
30539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30540       };
30541     } catch (std::exception& e) {
30542       {
30543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30544       };
30545     } catch (...) {
30546       {
30547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30548       };
30549     }
30550   }
30551   jresult = result;
30552   return jresult;
30553 }
30554
30555
30556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
30557   void * jresult ;
30558   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30559   Dali::Quaternion result;
30560
30561   arg1 = (Dali::Actor *)jarg1;
30562   {
30563     try {
30564       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
30565     } catch (std::out_of_range& e) {
30566       {
30567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30568       };
30569     } catch (std::exception& e) {
30570       {
30571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30572       };
30573     } catch (...) {
30574       {
30575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30576       };
30577     }
30578   }
30579   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30580   return jresult;
30581 }
30582
30583
30584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
30585   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30586   float arg2 ;
30587
30588   arg1 = (Dali::Actor *)jarg1;
30589   arg2 = (float)jarg2;
30590   {
30591     try {
30592       (arg1)->SetScale(arg2);
30593     } catch (std::out_of_range& e) {
30594       {
30595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30596       };
30597     } catch (std::exception& e) {
30598       {
30599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30600       };
30601     } catch (...) {
30602       {
30603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30604       };
30605     }
30606   }
30607 }
30608
30609
30610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30611   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30612   float arg2 ;
30613   float arg3 ;
30614   float arg4 ;
30615
30616   arg1 = (Dali::Actor *)jarg1;
30617   arg2 = (float)jarg2;
30618   arg3 = (float)jarg3;
30619   arg4 = (float)jarg4;
30620   {
30621     try {
30622       (arg1)->SetScale(arg2,arg3,arg4);
30623     } catch (std::out_of_range& e) {
30624       {
30625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30626       };
30627     } catch (std::exception& e) {
30628       {
30629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30630       };
30631     } catch (...) {
30632       {
30633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30634       };
30635     }
30636   }
30637 }
30638
30639
30640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
30641   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30642   Dali::Vector3 *arg2 = 0 ;
30643
30644   arg1 = (Dali::Actor *)jarg1;
30645   arg2 = (Dali::Vector3 *)jarg2;
30646   if (!arg2) {
30647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30648     return ;
30649   }
30650   {
30651     try {
30652       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
30653     } catch (std::out_of_range& e) {
30654       {
30655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30656       };
30657     } catch (std::exception& e) {
30658       {
30659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30660       };
30661     } catch (...) {
30662       {
30663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30664       };
30665     }
30666   }
30667 }
30668
30669
30670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
30671   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30672   Dali::Vector3 *arg2 = 0 ;
30673
30674   arg1 = (Dali::Actor *)jarg1;
30675   arg2 = (Dali::Vector3 *)jarg2;
30676   if (!arg2) {
30677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30678     return ;
30679   }
30680   {
30681     try {
30682       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
30683     } catch (std::out_of_range& e) {
30684       {
30685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30686       };
30687     } catch (std::exception& e) {
30688       {
30689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30690       };
30691     } catch (...) {
30692       {
30693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30694       };
30695     }
30696   }
30697 }
30698
30699
30700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
30701   void * jresult ;
30702   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30703   Dali::Vector3 result;
30704
30705   arg1 = (Dali::Actor *)jarg1;
30706   {
30707     try {
30708       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
30709     } catch (std::out_of_range& e) {
30710       {
30711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30712       };
30713     } catch (std::exception& e) {
30714       {
30715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30716       };
30717     } catch (...) {
30718       {
30719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30720       };
30721     }
30722   }
30723   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30724   return jresult;
30725 }
30726
30727
30728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
30729   void * jresult ;
30730   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30731   Dali::Vector3 result;
30732
30733   arg1 = (Dali::Actor *)jarg1;
30734   {
30735     try {
30736       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
30737     } catch (std::out_of_range& e) {
30738       {
30739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30740       };
30741     } catch (std::exception& e) {
30742       {
30743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30744       };
30745     } catch (...) {
30746       {
30747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30748       };
30749     }
30750   }
30751   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30752   return jresult;
30753 }
30754
30755
30756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
30757   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30758   bool arg2 ;
30759
30760   arg1 = (Dali::Actor *)jarg1;
30761   arg2 = jarg2 ? true : false;
30762   {
30763     try {
30764       (arg1)->SetInheritScale(arg2);
30765     } catch (std::out_of_range& e) {
30766       {
30767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30768       };
30769     } catch (std::exception& e) {
30770       {
30771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30772       };
30773     } catch (...) {
30774       {
30775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30776       };
30777     }
30778   }
30779 }
30780
30781
30782 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
30783   unsigned int jresult ;
30784   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30785   bool result;
30786
30787   arg1 = (Dali::Actor *)jarg1;
30788   {
30789     try {
30790       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
30791     } catch (std::out_of_range& e) {
30792       {
30793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30794       };
30795     } catch (std::exception& e) {
30796       {
30797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30798       };
30799     } catch (...) {
30800       {
30801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30802       };
30803     }
30804   }
30805   jresult = result;
30806   return jresult;
30807 }
30808
30809
30810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
30811   void * jresult ;
30812   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30813   Dali::Matrix result;
30814
30815   arg1 = (Dali::Actor *)jarg1;
30816   {
30817     try {
30818       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
30819     } catch (std::out_of_range& e) {
30820       {
30821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30822       };
30823     } catch (std::exception& e) {
30824       {
30825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30826       };
30827     } catch (...) {
30828       {
30829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30830       };
30831     }
30832   }
30833   jresult = new Dali::Matrix((const Dali::Matrix &)result);
30834   return jresult;
30835 }
30836
30837
30838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
30839   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30840   bool arg2 ;
30841
30842   arg1 = (Dali::Actor *)jarg1;
30843   arg2 = jarg2 ? true : false;
30844   {
30845     try {
30846       (arg1)->SetVisible(arg2);
30847     } catch (std::out_of_range& e) {
30848       {
30849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30850       };
30851     } catch (std::exception& e) {
30852       {
30853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30854       };
30855     } catch (...) {
30856       {
30857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30858       };
30859     }
30860   }
30861 }
30862
30863
30864 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
30865   unsigned int jresult ;
30866   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30867   bool result;
30868
30869   arg1 = (Dali::Actor *)jarg1;
30870   {
30871     try {
30872       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
30873     } catch (std::out_of_range& e) {
30874       {
30875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30876       };
30877     } catch (std::exception& e) {
30878       {
30879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30880       };
30881     } catch (...) {
30882       {
30883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30884       };
30885     }
30886   }
30887   jresult = result;
30888   return jresult;
30889 }
30890
30891
30892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
30893   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30894   float arg2 ;
30895
30896   arg1 = (Dali::Actor *)jarg1;
30897   arg2 = (float)jarg2;
30898   {
30899     try {
30900       (arg1)->SetOpacity(arg2);
30901     } catch (std::out_of_range& e) {
30902       {
30903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30904       };
30905     } catch (std::exception& e) {
30906       {
30907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30908       };
30909     } catch (...) {
30910       {
30911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30912       };
30913     }
30914   }
30915 }
30916
30917
30918 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
30919   float jresult ;
30920   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30921   float result;
30922
30923   arg1 = (Dali::Actor *)jarg1;
30924   {
30925     try {
30926       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
30927     } catch (std::out_of_range& e) {
30928       {
30929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30930       };
30931     } catch (std::exception& e) {
30932       {
30933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30934       };
30935     } catch (...) {
30936       {
30937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30938       };
30939     }
30940   }
30941   jresult = result;
30942   return jresult;
30943 }
30944
30945
30946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
30947   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30948   Dali::Vector4 *arg2 = 0 ;
30949
30950   arg1 = (Dali::Actor *)jarg1;
30951   arg2 = (Dali::Vector4 *)jarg2;
30952   if (!arg2) {
30953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
30954     return ;
30955   }
30956   {
30957     try {
30958       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
30959     } catch (std::out_of_range& e) {
30960       {
30961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30962       };
30963     } catch (std::exception& e) {
30964       {
30965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30966       };
30967     } catch (...) {
30968       {
30969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30970       };
30971     }
30972   }
30973 }
30974
30975
30976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
30977   void * jresult ;
30978   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30979   Dali::Vector4 result;
30980
30981   arg1 = (Dali::Actor *)jarg1;
30982   {
30983     try {
30984       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
30985     } catch (std::out_of_range& e) {
30986       {
30987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30988       };
30989     } catch (std::exception& e) {
30990       {
30991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30992       };
30993     } catch (...) {
30994       {
30995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30996       };
30997     }
30998   }
30999   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31000   return jresult;
31001 }
31002
31003
31004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
31005   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31006   Dali::ColorMode arg2 ;
31007
31008   arg1 = (Dali::Actor *)jarg1;
31009   arg2 = (Dali::ColorMode)jarg2;
31010   {
31011     try {
31012       (arg1)->SetColorMode(arg2);
31013     } catch (std::out_of_range& e) {
31014       {
31015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31016       };
31017     } catch (std::exception& e) {
31018       {
31019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31020       };
31021     } catch (...) {
31022       {
31023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31024       };
31025     }
31026   }
31027 }
31028
31029
31030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
31031   int jresult ;
31032   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31033   Dali::ColorMode result;
31034
31035   arg1 = (Dali::Actor *)jarg1;
31036   {
31037     try {
31038       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
31039     } catch (std::out_of_range& e) {
31040       {
31041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31042       };
31043     } catch (std::exception& e) {
31044       {
31045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31046       };
31047     } catch (...) {
31048       {
31049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31050       };
31051     }
31052   }
31053   jresult = (int)result;
31054   return jresult;
31055 }
31056
31057
31058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
31059   void * jresult ;
31060   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31061   Dali::Vector4 result;
31062
31063   arg1 = (Dali::Actor *)jarg1;
31064   {
31065     try {
31066       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
31067     } catch (std::out_of_range& e) {
31068       {
31069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31070       };
31071     } catch (std::exception& e) {
31072       {
31073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31074       };
31075     } catch (...) {
31076       {
31077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31078       };
31079     }
31080   }
31081   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31082   return jresult;
31083 }
31084
31085
31086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
31087   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31088   Dali::DrawMode::Type arg2 ;
31089
31090   arg1 = (Dali::Actor *)jarg1;
31091   arg2 = (Dali::DrawMode::Type)jarg2;
31092   {
31093     try {
31094       (arg1)->SetDrawMode(arg2);
31095     } catch (std::out_of_range& e) {
31096       {
31097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31098       };
31099     } catch (std::exception& e) {
31100       {
31101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31102       };
31103     } catch (...) {
31104       {
31105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31106       };
31107     }
31108   }
31109 }
31110
31111
31112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
31113   int jresult ;
31114   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31115   Dali::DrawMode::Type result;
31116
31117   arg1 = (Dali::Actor *)jarg1;
31118   {
31119     try {
31120       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
31121     } catch (std::out_of_range& e) {
31122       {
31123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31124       };
31125     } catch (std::exception& e) {
31126       {
31127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31128       };
31129     } catch (...) {
31130       {
31131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31132       };
31133     }
31134   }
31135   jresult = (int)result;
31136   return jresult;
31137 }
31138
31139
31140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
31141   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31142   bool arg2 ;
31143
31144   arg1 = (Dali::Actor *)jarg1;
31145   arg2 = jarg2 ? true : false;
31146   {
31147     try {
31148       (arg1)->SetSensitive(arg2);
31149     } catch (std::out_of_range& e) {
31150       {
31151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31152       };
31153     } catch (std::exception& e) {
31154       {
31155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31156       };
31157     } catch (...) {
31158       {
31159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31160       };
31161     }
31162   }
31163 }
31164
31165
31166 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
31167   unsigned int jresult ;
31168   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31169   bool result;
31170
31171   arg1 = (Dali::Actor *)jarg1;
31172   {
31173     try {
31174       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
31175     } catch (std::out_of_range& e) {
31176       {
31177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31178       };
31179     } catch (std::exception& e) {
31180       {
31181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31182       };
31183     } catch (...) {
31184       {
31185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31186       };
31187     }
31188   }
31189   jresult = result;
31190   return jresult;
31191 }
31192
31193
31194 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
31195   unsigned int jresult ;
31196   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31197   float *arg2 = 0 ;
31198   float *arg3 = 0 ;
31199   float arg4 ;
31200   float arg5 ;
31201   bool result;
31202
31203   arg1 = (Dali::Actor *)jarg1;
31204   arg2 = (float *)jarg2;
31205   arg3 = (float *)jarg3;
31206   arg4 = (float)jarg4;
31207   arg5 = (float)jarg5;
31208   {
31209     try {
31210       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
31211     } catch (std::out_of_range& e) {
31212       {
31213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31214       };
31215     } catch (std::exception& e) {
31216       {
31217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31218       };
31219     } catch (...) {
31220       {
31221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31222       };
31223     }
31224   }
31225   jresult = result;
31226   return jresult;
31227 }
31228
31229
31230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
31231   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31232   bool arg2 ;
31233
31234   arg1 = (Dali::Actor *)jarg1;
31235   arg2 = jarg2 ? true : false;
31236   {
31237     try {
31238       (arg1)->SetLeaveRequired(arg2);
31239     } catch (std::out_of_range& e) {
31240       {
31241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31242       };
31243     } catch (std::exception& e) {
31244       {
31245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31246       };
31247     } catch (...) {
31248       {
31249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31250       };
31251     }
31252   }
31253 }
31254
31255
31256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
31257   unsigned int jresult ;
31258   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31259   bool result;
31260
31261   arg1 = (Dali::Actor *)jarg1;
31262   {
31263     try {
31264       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
31265     } catch (std::out_of_range& e) {
31266       {
31267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31268       };
31269     } catch (std::exception& e) {
31270       {
31271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31272       };
31273     } catch (...) {
31274       {
31275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31276       };
31277     }
31278   }
31279   jresult = result;
31280   return jresult;
31281 }
31282
31283
31284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
31285   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31286   bool arg2 ;
31287
31288   arg1 = (Dali::Actor *)jarg1;
31289   arg2 = jarg2 ? true : false;
31290   {
31291     try {
31292       (arg1)->SetKeyboardFocusable(arg2);
31293     } catch (std::out_of_range& e) {
31294       {
31295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31296       };
31297     } catch (std::exception& e) {
31298       {
31299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31300       };
31301     } catch (...) {
31302       {
31303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31304       };
31305     }
31306   }
31307 }
31308
31309
31310 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
31311   unsigned int jresult ;
31312   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31313   bool result;
31314
31315   arg1 = (Dali::Actor *)jarg1;
31316   {
31317     try {
31318       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
31319     } catch (std::out_of_range& e) {
31320       {
31321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31322       };
31323     } catch (std::exception& e) {
31324       {
31325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31326       };
31327     } catch (...) {
31328       {
31329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31330       };
31331     }
31332   }
31333   jresult = result;
31334   return jresult;
31335 }
31336
31337
31338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
31339   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31340   Dali::ResizePolicy::Type arg2 ;
31341   Dali::Dimension::Type arg3 ;
31342
31343   arg1 = (Dali::Actor *)jarg1;
31344   arg2 = (Dali::ResizePolicy::Type)jarg2;
31345   arg3 = (Dali::Dimension::Type)jarg3;
31346   {
31347     try {
31348       (arg1)->SetResizePolicy(arg2,arg3);
31349     } catch (std::out_of_range& e) {
31350       {
31351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31352       };
31353     } catch (std::exception& e) {
31354       {
31355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31356       };
31357     } catch (...) {
31358       {
31359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31360       };
31361     }
31362   }
31363 }
31364
31365
31366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
31367   int jresult ;
31368   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31369   Dali::Dimension::Type arg2 ;
31370   Dali::ResizePolicy::Type result;
31371
31372   arg1 = (Dali::Actor *)jarg1;
31373   arg2 = (Dali::Dimension::Type)jarg2;
31374   {
31375     try {
31376       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
31377     } catch (std::out_of_range& e) {
31378       {
31379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31380       };
31381     } catch (std::exception& e) {
31382       {
31383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31384       };
31385     } catch (...) {
31386       {
31387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31388       };
31389     }
31390   }
31391   jresult = (int)result;
31392   return jresult;
31393 }
31394
31395
31396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
31397   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31398   Dali::SizeScalePolicy::Type arg2 ;
31399
31400   arg1 = (Dali::Actor *)jarg1;
31401   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
31402   {
31403     try {
31404       (arg1)->SetSizeScalePolicy(arg2);
31405     } catch (std::out_of_range& e) {
31406       {
31407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31408       };
31409     } catch (std::exception& e) {
31410       {
31411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31412       };
31413     } catch (...) {
31414       {
31415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31416       };
31417     }
31418   }
31419 }
31420
31421
31422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
31423   int jresult ;
31424   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31425   Dali::SizeScalePolicy::Type result;
31426
31427   arg1 = (Dali::Actor *)jarg1;
31428   {
31429     try {
31430       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
31431     } catch (std::out_of_range& e) {
31432       {
31433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31434       };
31435     } catch (std::exception& e) {
31436       {
31437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31438       };
31439     } catch (...) {
31440       {
31441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31442       };
31443     }
31444   }
31445   jresult = (int)result;
31446   return jresult;
31447 }
31448
31449
31450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
31451   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31452   Dali::Vector3 *arg2 = 0 ;
31453
31454   arg1 = (Dali::Actor *)jarg1;
31455   arg2 = (Dali::Vector3 *)jarg2;
31456   if (!arg2) {
31457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31458     return ;
31459   }
31460   {
31461     try {
31462       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
31463     } catch (std::out_of_range& e) {
31464       {
31465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31466       };
31467     } catch (std::exception& e) {
31468       {
31469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31470       };
31471     } catch (...) {
31472       {
31473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31474       };
31475     }
31476   }
31477 }
31478
31479
31480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
31481   void * jresult ;
31482   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31483   Dali::Vector3 result;
31484
31485   arg1 = (Dali::Actor *)jarg1;
31486   {
31487     try {
31488       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
31489     } catch (std::out_of_range& e) {
31490       {
31491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31492       };
31493     } catch (std::exception& e) {
31494       {
31495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31496       };
31497     } catch (...) {
31498       {
31499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31500       };
31501     }
31502   }
31503   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31504   return jresult;
31505 }
31506
31507
31508 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
31509   float jresult ;
31510   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31511   float arg2 ;
31512   float result;
31513
31514   arg1 = (Dali::Actor *)jarg1;
31515   arg2 = (float)jarg2;
31516   {
31517     try {
31518       result = (float)(arg1)->GetHeightForWidth(arg2);
31519     } catch (std::out_of_range& e) {
31520       {
31521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31522       };
31523     } catch (std::exception& e) {
31524       {
31525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31526       };
31527     } catch (...) {
31528       {
31529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31530       };
31531     }
31532   }
31533   jresult = result;
31534   return jresult;
31535 }
31536
31537
31538 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
31539   float jresult ;
31540   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31541   float arg2 ;
31542   float result;
31543
31544   arg1 = (Dali::Actor *)jarg1;
31545   arg2 = (float)jarg2;
31546   {
31547     try {
31548       result = (float)(arg1)->GetWidthForHeight(arg2);
31549     } catch (std::out_of_range& e) {
31550       {
31551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31552       };
31553     } catch (std::exception& e) {
31554       {
31555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31556       };
31557     } catch (...) {
31558       {
31559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31560       };
31561     }
31562   }
31563   jresult = result;
31564   return jresult;
31565 }
31566
31567
31568 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
31569   float jresult ;
31570   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31571   Dali::Dimension::Type arg2 ;
31572   float result;
31573
31574   arg1 = (Dali::Actor *)jarg1;
31575   arg2 = (Dali::Dimension::Type)jarg2;
31576   {
31577     try {
31578       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
31579     } catch (std::out_of_range& e) {
31580       {
31581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31582       };
31583     } catch (std::exception& e) {
31584       {
31585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31586       };
31587     } catch (...) {
31588       {
31589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31590       };
31591     }
31592   }
31593   jresult = result;
31594   return jresult;
31595 }
31596
31597
31598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
31599   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31600   Dali::Padding *arg2 = 0 ;
31601
31602   arg1 = (Dali::Actor *)jarg1;
31603   arg2 = (Dali::Padding *)jarg2;
31604   if (!arg2) {
31605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
31606     return ;
31607   }
31608   {
31609     try {
31610       (arg1)->SetPadding((Dali::Padding const &)*arg2);
31611     } catch (std::out_of_range& e) {
31612       {
31613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31614       };
31615     } catch (std::exception& e) {
31616       {
31617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31618       };
31619     } catch (...) {
31620       {
31621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31622       };
31623     }
31624   }
31625 }
31626
31627
31628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
31629   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31630   Dali::Padding *arg2 = 0 ;
31631
31632   arg1 = (Dali::Actor *)jarg1;
31633   arg2 = (Dali::Padding *)jarg2;
31634   if (!arg2) {
31635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
31636     return ;
31637   }
31638   {
31639     try {
31640       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
31641     } catch (std::out_of_range& e) {
31642       {
31643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31644       };
31645     } catch (std::exception& e) {
31646       {
31647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31648       };
31649     } catch (...) {
31650       {
31651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31652       };
31653     }
31654   }
31655 }
31656
31657
31658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
31659   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31660   Dali::Vector2 *arg2 = 0 ;
31661
31662   arg1 = (Dali::Actor *)jarg1;
31663   arg2 = (Dali::Vector2 *)jarg2;
31664   if (!arg2) {
31665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31666     return ;
31667   }
31668   {
31669     try {
31670       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
31671     } catch (std::out_of_range& e) {
31672       {
31673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31674       };
31675     } catch (std::exception& e) {
31676       {
31677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31678       };
31679     } catch (...) {
31680       {
31681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31682       };
31683     }
31684   }
31685 }
31686
31687
31688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
31689   void * jresult ;
31690   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31691   Dali::Vector2 result;
31692
31693   arg1 = (Dali::Actor *)jarg1;
31694   {
31695     try {
31696       result = (arg1)->GetMinimumSize();
31697     } catch (std::out_of_range& e) {
31698       {
31699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31700       };
31701     } catch (std::exception& e) {
31702       {
31703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31704       };
31705     } catch (...) {
31706       {
31707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31708       };
31709     }
31710   }
31711   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
31712   return jresult;
31713 }
31714
31715
31716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
31717   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31718   Dali::Vector2 *arg2 = 0 ;
31719
31720   arg1 = (Dali::Actor *)jarg1;
31721   arg2 = (Dali::Vector2 *)jarg2;
31722   if (!arg2) {
31723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31724     return ;
31725   }
31726   {
31727     try {
31728       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
31729     } catch (std::out_of_range& e) {
31730       {
31731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31732       };
31733     } catch (std::exception& e) {
31734       {
31735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31736       };
31737     } catch (...) {
31738       {
31739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31740       };
31741     }
31742   }
31743 }
31744
31745
31746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
31747   void * jresult ;
31748   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31749   Dali::Vector2 result;
31750
31751   arg1 = (Dali::Actor *)jarg1;
31752   {
31753     try {
31754       result = (arg1)->GetMaximumSize();
31755     } catch (std::out_of_range& e) {
31756       {
31757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31758       };
31759     } catch (std::exception& e) {
31760       {
31761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31762       };
31763     } catch (...) {
31764       {
31765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31766       };
31767     }
31768   }
31769   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
31770   return jresult;
31771 }
31772
31773
31774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
31775   int jresult ;
31776   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31777   int result;
31778
31779   arg1 = (Dali::Actor *)jarg1;
31780   {
31781     try {
31782       result = (int)(arg1)->GetHierarchyDepth();
31783     } catch (std::out_of_range& e) {
31784       {
31785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31786       };
31787     } catch (std::exception& e) {
31788       {
31789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31790       };
31791     } catch (...) {
31792       {
31793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31794       };
31795     }
31796   }
31797   jresult = result;
31798   return jresult;
31799 }
31800
31801
31802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
31803   unsigned int jresult ;
31804   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31805   Dali::Renderer *arg2 = 0 ;
31806   unsigned int result;
31807
31808   arg1 = (Dali::Actor *)jarg1;
31809   arg2 = (Dali::Renderer *)jarg2;
31810   if (!arg2) {
31811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
31812     return 0;
31813   }
31814   {
31815     try {
31816       result = (unsigned int)(arg1)->AddRenderer(*arg2);
31817     } catch (std::out_of_range& e) {
31818       {
31819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31820       };
31821     } catch (std::exception& e) {
31822       {
31823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31824       };
31825     } catch (...) {
31826       {
31827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31828       };
31829     }
31830   }
31831   jresult = result;
31832   return jresult;
31833 }
31834
31835
31836 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
31837   unsigned int jresult ;
31838   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31839   unsigned int result;
31840
31841   arg1 = (Dali::Actor *)jarg1;
31842   {
31843     try {
31844       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
31845     } catch (std::out_of_range& e) {
31846       {
31847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31848       };
31849     } catch (std::exception& e) {
31850       {
31851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31852       };
31853     } catch (...) {
31854       {
31855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31856       };
31857     }
31858   }
31859   jresult = result;
31860   return jresult;
31861 }
31862
31863
31864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
31865   void * jresult ;
31866   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31867   unsigned int arg2 ;
31868   Dali::Renderer result;
31869
31870   arg1 = (Dali::Actor *)jarg1;
31871   arg2 = (unsigned int)jarg2;
31872   {
31873     try {
31874       result = (arg1)->GetRendererAt(arg2);
31875     } catch (std::out_of_range& e) {
31876       {
31877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31878       };
31879     } catch (std::exception& e) {
31880       {
31881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31882       };
31883     } catch (...) {
31884       {
31885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31886       };
31887     }
31888   }
31889   jresult = new Dali::Renderer((const Dali::Renderer &)result);
31890   return jresult;
31891 }
31892
31893
31894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
31895   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31896   Dali::Renderer *arg2 = 0 ;
31897
31898   arg1 = (Dali::Actor *)jarg1;
31899   arg2 = (Dali::Renderer *)jarg2;
31900   if (!arg2) {
31901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
31902     return ;
31903   }
31904   {
31905     try {
31906       (arg1)->RemoveRenderer(*arg2);
31907     } catch (std::out_of_range& e) {
31908       {
31909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31910       };
31911     } catch (std::exception& e) {
31912       {
31913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31914       };
31915     } catch (...) {
31916       {
31917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31918       };
31919     }
31920   }
31921 }
31922
31923
31924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
31925   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31926   unsigned int arg2 ;
31927
31928   arg1 = (Dali::Actor *)jarg1;
31929   arg2 = (unsigned int)jarg2;
31930   {
31931     try {
31932       (arg1)->RemoveRenderer(arg2);
31933     } catch (std::out_of_range& e) {
31934       {
31935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31936       };
31937     } catch (std::exception& e) {
31938       {
31939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31940       };
31941     } catch (...) {
31942       {
31943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31944       };
31945     }
31946   }
31947 }
31948
31949
31950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
31951   void * jresult ;
31952   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31953   Dali::Actor::TouchSignalType *result = 0 ;
31954
31955   arg1 = (Dali::Actor *)jarg1;
31956   {
31957     try {
31958       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
31959     } catch (std::out_of_range& e) {
31960       {
31961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31962       };
31963     } catch (std::exception& e) {
31964       {
31965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31966       };
31967     } catch (...) {
31968       {
31969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31970       };
31971     }
31972   }
31973   jresult = (void *)result;
31974   return jresult;
31975 }
31976
31977
31978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
31979   void * jresult ;
31980   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31981   Dali::Actor::TouchDataSignalType *result = 0 ;
31982
31983   arg1 = (Dali::Actor *)jarg1;
31984   {
31985     try {
31986       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
31987     } catch (std::out_of_range& e) {
31988       {
31989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31990       };
31991     } catch (std::exception& e) {
31992       {
31993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31994       };
31995     } catch (...) {
31996       {
31997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31998       };
31999     }
32000   }
32001   jresult = (void *)result;
32002   return jresult;
32003 }
32004
32005
32006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
32007   void * jresult ;
32008   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32009   Dali::Actor::HoverSignalType *result = 0 ;
32010
32011   arg1 = (Dali::Actor *)jarg1;
32012   {
32013     try {
32014       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
32015     } catch (std::out_of_range& e) {
32016       {
32017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32018       };
32019     } catch (std::exception& e) {
32020       {
32021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32022       };
32023     } catch (...) {
32024       {
32025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32026       };
32027     }
32028   }
32029   jresult = (void *)result;
32030   return jresult;
32031 }
32032
32033
32034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
32035   void * jresult ;
32036   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32037   Dali::Actor::WheelEventSignalType *result = 0 ;
32038
32039   arg1 = (Dali::Actor *)jarg1;
32040   {
32041     try {
32042       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
32043     } catch (std::out_of_range& e) {
32044       {
32045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32046       };
32047     } catch (std::exception& e) {
32048       {
32049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32050       };
32051     } catch (...) {
32052       {
32053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32054       };
32055     }
32056   }
32057   jresult = (void *)result;
32058   return jresult;
32059 }
32060
32061
32062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
32063   void * jresult ;
32064   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32065   Dali::Actor::OnStageSignalType *result = 0 ;
32066
32067   arg1 = (Dali::Actor *)jarg1;
32068   {
32069     try {
32070       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
32071     } catch (std::out_of_range& e) {
32072       {
32073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32074       };
32075     } catch (std::exception& e) {
32076       {
32077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32078       };
32079     } catch (...) {
32080       {
32081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32082       };
32083     }
32084   }
32085   jresult = (void *)result;
32086   return jresult;
32087 }
32088
32089
32090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
32091   void * jresult ;
32092   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32093   Dali::Actor::OffStageSignalType *result = 0 ;
32094
32095   arg1 = (Dali::Actor *)jarg1;
32096   {
32097     try {
32098       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
32099     } catch (std::out_of_range& e) {
32100       {
32101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32102       };
32103     } catch (std::exception& e) {
32104       {
32105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32106       };
32107     } catch (...) {
32108       {
32109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32110       };
32111     }
32112   }
32113   jresult = (void *)result;
32114   return jresult;
32115 }
32116
32117
32118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
32119   void * jresult ;
32120   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32121   Dali::Actor::OnRelayoutSignalType *result = 0 ;
32122
32123   arg1 = (Dali::Actor *)jarg1;
32124   {
32125     try {
32126       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
32127     } catch (std::out_of_range& e) {
32128       {
32129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32130       };
32131     } catch (std::exception& e) {
32132       {
32133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32134       };
32135     } catch (...) {
32136       {
32137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32138       };
32139     }
32140   }
32141   jresult = (void *)result;
32142   return jresult;
32143 }
32144
32145
32146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
32147   Dali::Actor *arg1 = 0 ;
32148
32149   arg1 = (Dali::Actor *)jarg1;
32150   if (!arg1) {
32151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
32152     return ;
32153   }
32154   {
32155     try {
32156       Dali::UnparentAndReset(*arg1);
32157     } catch (std::out_of_range& e) {
32158       {
32159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32160       };
32161     } catch (std::exception& e) {
32162       {
32163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32164       };
32165     } catch (...) {
32166       {
32167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32168       };
32169     }
32170   }
32171 }
32172
32173
32174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32175   Dali::Actor arg1 ;
32176   Dali::Actor *argp1 ;
32177
32178   argp1 = (Dali::Actor *)jarg1;
32179   if (!argp1) {
32180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32181     return ;
32182   }
32183   arg1 = *argp1;
32184   {
32185     try {
32186       Dali::DevelActor::Raise(arg1);
32187     } catch (std::out_of_range& e) {
32188       {
32189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32190       };
32191     } catch (std::exception& e) {
32192       {
32193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32194       };
32195     } catch (...) {
32196       {
32197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32198       };
32199     }
32200   }
32201 }
32202
32203
32204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32205   Dali::Actor arg1 ;
32206   Dali::Actor *argp1 ;
32207
32208   argp1 = (Dali::Actor *)jarg1;
32209   if (!argp1) {
32210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32211     return ;
32212   }
32213   arg1 = *argp1;
32214   {
32215     try {
32216       Dali::DevelActor::Lower(arg1);
32217     } catch (std::out_of_range& e) {
32218       {
32219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32220       };
32221     } catch (std::exception& e) {
32222       {
32223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32224       };
32225     } catch (...) {
32226       {
32227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32228       };
32229     }
32230   }
32231 }
32232
32233
32234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32235   Dali::Actor arg1 ;
32236   Dali::Actor *argp1 ;
32237
32238   argp1 = (Dali::Actor *)jarg1;
32239   if (!argp1) {
32240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32241     return ;
32242   }
32243   arg1 = *argp1;
32244   {
32245     try {
32246       Dali::DevelActor::RaiseToTop(arg1);
32247     } catch (std::out_of_range& e) {
32248       {
32249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32250       };
32251     } catch (std::exception& e) {
32252       {
32253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32254       };
32255     } catch (...) {
32256       {
32257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32258       };
32259     }
32260   }
32261 }
32262
32263
32264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32265   Dali::Actor arg1 ;
32266   Dali::Actor *argp1 ;
32267
32268   argp1 = (Dali::Actor *)jarg1;
32269   if (!argp1) {
32270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32271     return ;
32272   }
32273   arg1 = *argp1;
32274   {
32275     try {
32276       Dali::DevelActor::LowerToBottom(arg1);
32277     } catch (std::out_of_range& e) {
32278       {
32279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32280       };
32281     } catch (std::exception& e) {
32282       {
32283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32284       };
32285     } catch (...) {
32286       {
32287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32288       };
32289     }
32290   }
32291 }
32292
32293
32294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32295   Dali::Actor arg1 ;
32296   Dali::Actor arg2 ;
32297   Dali::Actor *argp1 ;
32298   Dali::Actor *argp2 ;
32299
32300   argp1 = (Dali::Actor *)jarg1;
32301   if (!argp1) {
32302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32303     return ;
32304   }
32305   arg1 = *argp1;
32306   argp2 = (Dali::Actor *)jarg2;
32307   if (!argp2) {
32308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32309     return ;
32310   }
32311   arg2 = *argp2;
32312   {
32313     try {
32314       Dali::DevelActor::RaiseAbove(arg1,arg2);
32315     } catch (std::out_of_range& e) {
32316       {
32317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32318       };
32319     } catch (std::exception& e) {
32320       {
32321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32322       };
32323     } catch (...) {
32324       {
32325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32326       };
32327     }
32328   }
32329 }
32330
32331
32332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32333   Dali::Actor arg1 ;
32334   Dali::Actor arg2 ;
32335   Dali::Actor *argp1 ;
32336   Dali::Actor *argp2 ;
32337
32338   argp1 = (Dali::Actor *)jarg1;
32339   if (!argp1) {
32340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32341     return ;
32342   }
32343   arg1 = *argp1;
32344   argp2 = (Dali::Actor *)jarg2;
32345   if (!argp2) {
32346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32347     return ;
32348   }
32349   arg2 = *argp2;
32350   {
32351     try {
32352       Dali::DevelActor::LowerBelow(arg1,arg2);
32353     } catch (std::out_of_range& e) {
32354       {
32355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32356       };
32357     } catch (std::exception& e) {
32358       {
32359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32360       };
32361     } catch (...) {
32362       {
32363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32364       };
32365     }
32366   }
32367 }
32368
32369
32370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
32371   int jresult ;
32372   int result;
32373
32374   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
32375   jresult = (int)result;
32376   return jresult;
32377 }
32378
32379
32380 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
32381   int jresult ;
32382   int result;
32383
32384   result = (int)Dali::Layer::Property::CLIPPING_BOX;
32385   jresult = (int)result;
32386   return jresult;
32387 }
32388
32389
32390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
32391   int jresult ;
32392   int result;
32393
32394   result = (int)Dali::Layer::Property::BEHAVIOR;
32395   jresult = (int)result;
32396   return jresult;
32397 }
32398
32399
32400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
32401   void * jresult ;
32402   Dali::Layer::Property *result = 0 ;
32403
32404   {
32405     try {
32406       result = (Dali::Layer::Property *)new Dali::Layer::Property();
32407     } catch (std::out_of_range& e) {
32408       {
32409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32410       };
32411     } catch (std::exception& e) {
32412       {
32413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32414       };
32415     } catch (...) {
32416       {
32417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32418       };
32419     }
32420   }
32421   jresult = (void *)result;
32422   return jresult;
32423 }
32424
32425
32426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
32427   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
32428
32429   arg1 = (Dali::Layer::Property *)jarg1;
32430   {
32431     try {
32432       delete arg1;
32433     } catch (std::out_of_range& e) {
32434       {
32435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32436       };
32437     } catch (std::exception& e) {
32438       {
32439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32440       };
32441     } catch (...) {
32442       {
32443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32444       };
32445     }
32446   }
32447 }
32448
32449
32450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
32451   void * jresult ;
32452   Dali::Layer *result = 0 ;
32453
32454   {
32455     try {
32456       result = (Dali::Layer *)new Dali::Layer();
32457     } catch (std::out_of_range& e) {
32458       {
32459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32460       };
32461     } catch (std::exception& e) {
32462       {
32463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32464       };
32465     } catch (...) {
32466       {
32467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32468       };
32469     }
32470   }
32471   jresult = (void *)result;
32472   return jresult;
32473 }
32474
32475
32476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
32477   void * jresult ;
32478   Dali::Layer result;
32479
32480   {
32481     try {
32482       result = Dali::Layer::New();
32483     } catch (std::out_of_range& e) {
32484       {
32485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32486       };
32487     } catch (std::exception& e) {
32488       {
32489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32490       };
32491     } catch (...) {
32492       {
32493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32494       };
32495     }
32496   }
32497   jresult = new Dali::Layer((const Dali::Layer &)result);
32498   return jresult;
32499 }
32500
32501
32502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
32503   void * jresult ;
32504   Dali::BaseHandle arg1 ;
32505   Dali::BaseHandle *argp1 ;
32506   Dali::Layer result;
32507
32508   argp1 = (Dali::BaseHandle *)jarg1;
32509   if (!argp1) {
32510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
32511     return 0;
32512   }
32513   arg1 = *argp1;
32514   {
32515     try {
32516       result = Dali::Layer::DownCast(arg1);
32517     } catch (std::out_of_range& e) {
32518       {
32519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32520       };
32521     } catch (std::exception& e) {
32522       {
32523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32524       };
32525     } catch (...) {
32526       {
32527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32528       };
32529     }
32530   }
32531   jresult = new Dali::Layer((const Dali::Layer &)result);
32532   return jresult;
32533 }
32534
32535
32536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
32537   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32538
32539   arg1 = (Dali::Layer *)jarg1;
32540   {
32541     try {
32542       delete arg1;
32543     } catch (std::out_of_range& e) {
32544       {
32545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32546       };
32547     } catch (std::exception& e) {
32548       {
32549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32550       };
32551     } catch (...) {
32552       {
32553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32554       };
32555     }
32556   }
32557 }
32558
32559
32560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
32561   void * jresult ;
32562   Dali::Layer *arg1 = 0 ;
32563   Dali::Layer *result = 0 ;
32564
32565   arg1 = (Dali::Layer *)jarg1;
32566   if (!arg1) {
32567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32568     return 0;
32569   }
32570   {
32571     try {
32572       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
32573     } catch (std::out_of_range& e) {
32574       {
32575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32576       };
32577     } catch (std::exception& e) {
32578       {
32579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32580       };
32581     } catch (...) {
32582       {
32583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32584       };
32585     }
32586   }
32587   jresult = (void *)result;
32588   return jresult;
32589 }
32590
32591
32592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
32593   void * jresult ;
32594   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32595   Dali::Layer *arg2 = 0 ;
32596   Dali::Layer *result = 0 ;
32597
32598   arg1 = (Dali::Layer *)jarg1;
32599   arg2 = (Dali::Layer *)jarg2;
32600   if (!arg2) {
32601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32602     return 0;
32603   }
32604   {
32605     try {
32606       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
32607     } catch (std::out_of_range& e) {
32608       {
32609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32610       };
32611     } catch (std::exception& e) {
32612       {
32613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32614       };
32615     } catch (...) {
32616       {
32617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32618       };
32619     }
32620   }
32621   jresult = (void *)result;
32622   return jresult;
32623 }
32624
32625
32626 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
32627   unsigned int jresult ;
32628   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32629   unsigned int result;
32630
32631   arg1 = (Dali::Layer *)jarg1;
32632   {
32633     try {
32634       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
32635     } catch (std::out_of_range& e) {
32636       {
32637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32638       };
32639     } catch (std::exception& e) {
32640       {
32641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32642       };
32643     } catch (...) {
32644       {
32645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32646       };
32647     }
32648   }
32649   jresult = result;
32650   return jresult;
32651 }
32652
32653
32654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
32655   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32656
32657   arg1 = (Dali::Layer *)jarg1;
32658   {
32659     try {
32660       (arg1)->Raise();
32661     } catch (std::out_of_range& e) {
32662       {
32663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32664       };
32665     } catch (std::exception& e) {
32666       {
32667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32668       };
32669     } catch (...) {
32670       {
32671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32672       };
32673     }
32674   }
32675 }
32676
32677
32678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
32679   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32680
32681   arg1 = (Dali::Layer *)jarg1;
32682   {
32683     try {
32684       (arg1)->Lower();
32685     } catch (std::out_of_range& e) {
32686       {
32687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32688       };
32689     } catch (std::exception& e) {
32690       {
32691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32692       };
32693     } catch (...) {
32694       {
32695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32696       };
32697     }
32698   }
32699 }
32700
32701
32702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
32703   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32704   Dali::Layer arg2 ;
32705   Dali::Layer *argp2 ;
32706
32707   arg1 = (Dali::Layer *)jarg1;
32708   argp2 = (Dali::Layer *)jarg2;
32709   if (!argp2) {
32710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32711     return ;
32712   }
32713   arg2 = *argp2;
32714   {
32715     try {
32716       (arg1)->RaiseAbove(arg2);
32717     } catch (std::out_of_range& e) {
32718       {
32719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32720       };
32721     } catch (std::exception& e) {
32722       {
32723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32724       };
32725     } catch (...) {
32726       {
32727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32728       };
32729     }
32730   }
32731 }
32732
32733
32734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
32735   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32736   Dali::Layer arg2 ;
32737   Dali::Layer *argp2 ;
32738
32739   arg1 = (Dali::Layer *)jarg1;
32740   argp2 = (Dali::Layer *)jarg2;
32741   if (!argp2) {
32742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32743     return ;
32744   }
32745   arg2 = *argp2;
32746   {
32747     try {
32748       (arg1)->LowerBelow(arg2);
32749     } catch (std::out_of_range& e) {
32750       {
32751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32752       };
32753     } catch (std::exception& e) {
32754       {
32755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32756       };
32757     } catch (...) {
32758       {
32759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32760       };
32761     }
32762   }
32763 }
32764
32765
32766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
32767   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32768
32769   arg1 = (Dali::Layer *)jarg1;
32770   {
32771     try {
32772       (arg1)->RaiseToTop();
32773     } catch (std::out_of_range& e) {
32774       {
32775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32776       };
32777     } catch (std::exception& e) {
32778       {
32779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32780       };
32781     } catch (...) {
32782       {
32783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32784       };
32785     }
32786   }
32787 }
32788
32789
32790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
32791   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32792
32793   arg1 = (Dali::Layer *)jarg1;
32794   {
32795     try {
32796       (arg1)->LowerToBottom();
32797     } catch (std::out_of_range& e) {
32798       {
32799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32800       };
32801     } catch (std::exception& e) {
32802       {
32803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32804       };
32805     } catch (...) {
32806       {
32807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32808       };
32809     }
32810   }
32811 }
32812
32813
32814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
32815   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32816   Dali::Layer arg2 ;
32817   Dali::Layer *argp2 ;
32818
32819   arg1 = (Dali::Layer *)jarg1;
32820   argp2 = (Dali::Layer *)jarg2;
32821   if (!argp2) {
32822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32823     return ;
32824   }
32825   arg2 = *argp2;
32826   {
32827     try {
32828       (arg1)->MoveAbove(arg2);
32829     } catch (std::out_of_range& e) {
32830       {
32831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32832       };
32833     } catch (std::exception& e) {
32834       {
32835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32836       };
32837     } catch (...) {
32838       {
32839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32840       };
32841     }
32842   }
32843 }
32844
32845
32846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
32847   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32848   Dali::Layer arg2 ;
32849   Dali::Layer *argp2 ;
32850
32851   arg1 = (Dali::Layer *)jarg1;
32852   argp2 = (Dali::Layer *)jarg2;
32853   if (!argp2) {
32854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32855     return ;
32856   }
32857   arg2 = *argp2;
32858   {
32859     try {
32860       (arg1)->MoveBelow(arg2);
32861     } catch (std::out_of_range& e) {
32862       {
32863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32864       };
32865     } catch (std::exception& e) {
32866       {
32867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32868       };
32869     } catch (...) {
32870       {
32871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32872       };
32873     }
32874   }
32875 }
32876
32877
32878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
32879   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32880   Dali::Layer::Behavior arg2 ;
32881
32882   arg1 = (Dali::Layer *)jarg1;
32883   arg2 = (Dali::Layer::Behavior)jarg2;
32884   {
32885     try {
32886       (arg1)->SetBehavior(arg2);
32887     } catch (std::out_of_range& e) {
32888       {
32889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32890       };
32891     } catch (std::exception& e) {
32892       {
32893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32894       };
32895     } catch (...) {
32896       {
32897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32898       };
32899     }
32900   }
32901 }
32902
32903
32904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
32905   int jresult ;
32906   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32907   Dali::Layer::Behavior result;
32908
32909   arg1 = (Dali::Layer *)jarg1;
32910   {
32911     try {
32912       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
32913     } catch (std::out_of_range& e) {
32914       {
32915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32916       };
32917     } catch (std::exception& e) {
32918       {
32919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32920       };
32921     } catch (...) {
32922       {
32923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32924       };
32925     }
32926   }
32927   jresult = (int)result;
32928   return jresult;
32929 }
32930
32931
32932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
32933   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32934   bool arg2 ;
32935
32936   arg1 = (Dali::Layer *)jarg1;
32937   arg2 = jarg2 ? true : false;
32938   {
32939     try {
32940       (arg1)->SetClipping(arg2);
32941     } catch (std::out_of_range& e) {
32942       {
32943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32944       };
32945     } catch (std::exception& e) {
32946       {
32947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32948       };
32949     } catch (...) {
32950       {
32951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32952       };
32953     }
32954   }
32955 }
32956
32957
32958 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
32959   unsigned int jresult ;
32960   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32961   bool result;
32962
32963   arg1 = (Dali::Layer *)jarg1;
32964   {
32965     try {
32966       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
32967     } catch (std::out_of_range& e) {
32968       {
32969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32970       };
32971     } catch (std::exception& e) {
32972       {
32973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32974       };
32975     } catch (...) {
32976       {
32977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32978       };
32979     }
32980   }
32981   jresult = result;
32982   return jresult;
32983 }
32984
32985
32986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
32987   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32988   int arg2 ;
32989   int arg3 ;
32990   int arg4 ;
32991   int arg5 ;
32992
32993   arg1 = (Dali::Layer *)jarg1;
32994   arg2 = (int)jarg2;
32995   arg3 = (int)jarg3;
32996   arg4 = (int)jarg4;
32997   arg5 = (int)jarg5;
32998   {
32999     try {
33000       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
33001     } catch (std::out_of_range& e) {
33002       {
33003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33004       };
33005     } catch (std::exception& e) {
33006       {
33007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33008       };
33009     } catch (...) {
33010       {
33011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33012       };
33013     }
33014   }
33015 }
33016
33017
33018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
33019   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33020   Dali::ClippingBox arg2 ;
33021   Dali::ClippingBox *argp2 ;
33022
33023   arg1 = (Dali::Layer *)jarg1;
33024   argp2 = (Dali::ClippingBox *)jarg2;
33025   if (!argp2) {
33026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
33027     return ;
33028   }
33029   arg2 = *argp2;
33030   {
33031     try {
33032       (arg1)->SetClippingBox(arg2);
33033     } catch (std::out_of_range& e) {
33034       {
33035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33036       };
33037     } catch (std::exception& e) {
33038       {
33039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33040       };
33041     } catch (...) {
33042       {
33043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33044       };
33045     }
33046   }
33047 }
33048
33049
33050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
33051   void * jresult ;
33052   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33053   Dali::ClippingBox result;
33054
33055   arg1 = (Dali::Layer *)jarg1;
33056   {
33057     try {
33058       result = ((Dali::Layer const *)arg1)->GetClippingBox();
33059     } catch (std::out_of_range& e) {
33060       {
33061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33062       };
33063     } catch (std::exception& e) {
33064       {
33065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33066       };
33067     } catch (...) {
33068       {
33069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33070       };
33071     }
33072   }
33073   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
33074   return jresult;
33075 }
33076
33077
33078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
33079   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33080   bool arg2 ;
33081
33082   arg1 = (Dali::Layer *)jarg1;
33083   arg2 = jarg2 ? true : false;
33084   {
33085     try {
33086       (arg1)->SetDepthTestDisabled(arg2);
33087     } catch (std::out_of_range& e) {
33088       {
33089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33090       };
33091     } catch (std::exception& e) {
33092       {
33093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33094       };
33095     } catch (...) {
33096       {
33097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33098       };
33099     }
33100   }
33101 }
33102
33103
33104 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
33105   unsigned int jresult ;
33106   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33107   bool result;
33108
33109   arg1 = (Dali::Layer *)jarg1;
33110   {
33111     try {
33112       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
33113     } catch (std::out_of_range& e) {
33114       {
33115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33116       };
33117     } catch (std::exception& e) {
33118       {
33119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33120       };
33121     } catch (...) {
33122       {
33123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33124       };
33125     }
33126   }
33127   jresult = result;
33128   return jresult;
33129 }
33130
33131
33132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
33133   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33134   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
33135
33136   arg1 = (Dali::Layer *)jarg1;
33137   arg2 = (Dali::Layer::SortFunctionType)jarg2;
33138   {
33139     try {
33140       (arg1)->SetSortFunction(arg2);
33141     } catch (std::out_of_range& e) {
33142       {
33143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33144       };
33145     } catch (std::exception& e) {
33146       {
33147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33148       };
33149     } catch (...) {
33150       {
33151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33152       };
33153     }
33154   }
33155 }
33156
33157
33158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
33159   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33160   bool arg2 ;
33161
33162   arg1 = (Dali::Layer *)jarg1;
33163   arg2 = jarg2 ? true : false;
33164   {
33165     try {
33166       (arg1)->SetTouchConsumed(arg2);
33167     } catch (std::out_of_range& e) {
33168       {
33169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33170       };
33171     } catch (std::exception& e) {
33172       {
33173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33174       };
33175     } catch (...) {
33176       {
33177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33178       };
33179     }
33180   }
33181 }
33182
33183
33184 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
33185   unsigned int jresult ;
33186   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33187   bool result;
33188
33189   arg1 = (Dali::Layer *)jarg1;
33190   {
33191     try {
33192       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
33193     } catch (std::out_of_range& e) {
33194       {
33195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33196       };
33197     } catch (std::exception& e) {
33198       {
33199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33200       };
33201     } catch (...) {
33202       {
33203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33204       };
33205     }
33206   }
33207   jresult = result;
33208   return jresult;
33209 }
33210
33211
33212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
33213   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33214   bool arg2 ;
33215
33216   arg1 = (Dali::Layer *)jarg1;
33217   arg2 = jarg2 ? true : false;
33218   {
33219     try {
33220       (arg1)->SetHoverConsumed(arg2);
33221     } catch (std::out_of_range& e) {
33222       {
33223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33224       };
33225     } catch (std::exception& e) {
33226       {
33227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33228       };
33229     } catch (...) {
33230       {
33231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33232       };
33233     }
33234   }
33235 }
33236
33237
33238 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
33239   unsigned int jresult ;
33240   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33241   bool result;
33242
33243   arg1 = (Dali::Layer *)jarg1;
33244   {
33245     try {
33246       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
33247     } catch (std::out_of_range& e) {
33248       {
33249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33250       };
33251     } catch (std::exception& e) {
33252       {
33253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33254       };
33255     } catch (...) {
33256       {
33257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33258       };
33259     }
33260   }
33261   jresult = result;
33262   return jresult;
33263 }
33264
33265
33266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
33267   void * jresult ;
33268   Dali::Vector4 *result = 0 ;
33269
33270   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
33271   jresult = (void *)result;
33272   return jresult;
33273 }
33274
33275
33276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
33277   void * jresult ;
33278   Dali::Vector4 *result = 0 ;
33279
33280   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
33281   jresult = (void *)result;
33282   return jresult;
33283 }
33284
33285
33286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
33287   void * jresult ;
33288   Dali::Stage *result = 0 ;
33289
33290   {
33291     try {
33292       result = (Dali::Stage *)new Dali::Stage();
33293     } catch (std::out_of_range& e) {
33294       {
33295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33296       };
33297     } catch (std::exception& e) {
33298       {
33299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33300       };
33301     } catch (...) {
33302       {
33303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33304       };
33305     }
33306   }
33307   jresult = (void *)result;
33308   return jresult;
33309 }
33310
33311
33312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
33313   void * jresult ;
33314   Dali::Stage result;
33315
33316   {
33317     try {
33318       result = Dali::Stage::GetCurrent();
33319     } catch (std::out_of_range& e) {
33320       {
33321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33322       };
33323     } catch (std::exception& e) {
33324       {
33325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33326       };
33327     } catch (...) {
33328       {
33329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33330       };
33331     }
33332   }
33333   jresult = new Dali::Stage((const Dali::Stage &)result);
33334   return jresult;
33335 }
33336
33337
33338 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
33339   unsigned int jresult ;
33340   bool result;
33341
33342   {
33343     try {
33344       result = (bool)Dali::Stage::IsInstalled();
33345     } catch (std::out_of_range& e) {
33346       {
33347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33348       };
33349     } catch (std::exception& e) {
33350       {
33351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33352       };
33353     } catch (...) {
33354       {
33355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33356       };
33357     }
33358   }
33359   jresult = result;
33360   return jresult;
33361 }
33362
33363
33364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
33365   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33366
33367   arg1 = (Dali::Stage *)jarg1;
33368   {
33369     try {
33370       delete arg1;
33371     } catch (std::out_of_range& e) {
33372       {
33373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33374       };
33375     } catch (std::exception& e) {
33376       {
33377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33378       };
33379     } catch (...) {
33380       {
33381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33382       };
33383     }
33384   }
33385 }
33386
33387
33388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
33389   void * jresult ;
33390   Dali::Stage *arg1 = 0 ;
33391   Dali::Stage *result = 0 ;
33392
33393   arg1 = (Dali::Stage *)jarg1;
33394   if (!arg1) {
33395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33396     return 0;
33397   }
33398   {
33399     try {
33400       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
33401     } catch (std::out_of_range& e) {
33402       {
33403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33404       };
33405     } catch (std::exception& e) {
33406       {
33407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33408       };
33409     } catch (...) {
33410       {
33411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33412       };
33413     }
33414   }
33415   jresult = (void *)result;
33416   return jresult;
33417 }
33418
33419
33420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
33421   void * jresult ;
33422   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33423   Dali::Stage *arg2 = 0 ;
33424   Dali::Stage *result = 0 ;
33425
33426   arg1 = (Dali::Stage *)jarg1;
33427   arg2 = (Dali::Stage *)jarg2;
33428   if (!arg2) {
33429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33430     return 0;
33431   }
33432   {
33433     try {
33434       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
33435     } catch (std::out_of_range& e) {
33436       {
33437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33438       };
33439     } catch (std::exception& e) {
33440       {
33441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33442       };
33443     } catch (...) {
33444       {
33445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33446       };
33447     }
33448   }
33449   jresult = (void *)result;
33450   return jresult;
33451 }
33452
33453
33454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
33455   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33456   Dali::Actor *arg2 = 0 ;
33457
33458   arg1 = (Dali::Stage *)jarg1;
33459   arg2 = (Dali::Actor *)jarg2;
33460   if (!arg2) {
33461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33462     return ;
33463   }
33464   {
33465     try {
33466       (arg1)->Add(*arg2);
33467     } catch (std::out_of_range& e) {
33468       {
33469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33470       };
33471     } catch (std::exception& e) {
33472       {
33473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33474       };
33475     } catch (...) {
33476       {
33477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33478       };
33479     }
33480   }
33481 }
33482
33483
33484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
33485   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33486   Dali::Actor *arg2 = 0 ;
33487
33488   arg1 = (Dali::Stage *)jarg1;
33489   arg2 = (Dali::Actor *)jarg2;
33490   if (!arg2) {
33491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33492     return ;
33493   }
33494   {
33495     try {
33496       (arg1)->Remove(*arg2);
33497     } catch (std::out_of_range& e) {
33498       {
33499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33500       };
33501     } catch (std::exception& e) {
33502       {
33503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33504       };
33505     } catch (...) {
33506       {
33507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33508       };
33509     }
33510   }
33511 }
33512
33513
33514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
33515   void * jresult ;
33516   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33517   Dali::Vector2 result;
33518
33519   arg1 = (Dali::Stage *)jarg1;
33520   {
33521     try {
33522       result = ((Dali::Stage const *)arg1)->GetSize();
33523     } catch (std::out_of_range& e) {
33524       {
33525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33526       };
33527     } catch (std::exception& e) {
33528       {
33529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33530       };
33531     } catch (...) {
33532       {
33533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33534       };
33535     }
33536   }
33537   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33538   return jresult;
33539 }
33540
33541
33542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
33543   void * jresult ;
33544   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33545   Dali::RenderTaskList result;
33546
33547   arg1 = (Dali::Stage *)jarg1;
33548   {
33549     try {
33550       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
33551     } catch (std::out_of_range& e) {
33552       {
33553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33554       };
33555     } catch (std::exception& e) {
33556       {
33557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33558       };
33559     } catch (...) {
33560       {
33561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33562       };
33563     }
33564   }
33565   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
33566   return jresult;
33567 }
33568
33569
33570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
33571   unsigned int jresult ;
33572   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33573   unsigned int result;
33574
33575   arg1 = (Dali::Stage *)jarg1;
33576   {
33577     try {
33578       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
33579     } catch (std::out_of_range& e) {
33580       {
33581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33582       };
33583     } catch (std::exception& e) {
33584       {
33585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33586       };
33587     } catch (...) {
33588       {
33589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33590       };
33591     }
33592   }
33593   jresult = result;
33594   return jresult;
33595 }
33596
33597
33598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
33599   void * jresult ;
33600   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33601   unsigned int arg2 ;
33602   Dali::Layer result;
33603
33604   arg1 = (Dali::Stage *)jarg1;
33605   arg2 = (unsigned int)jarg2;
33606   {
33607     try {
33608       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
33609     } catch (std::out_of_range& e) {
33610       {
33611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33612       };
33613     } catch (std::exception& e) {
33614       {
33615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33616       };
33617     } catch (...) {
33618       {
33619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33620       };
33621     }
33622   }
33623   jresult = new Dali::Layer((const Dali::Layer &)result);
33624   return jresult;
33625 }
33626
33627
33628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
33629   void * jresult ;
33630   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33631   Dali::Layer result;
33632
33633   arg1 = (Dali::Stage *)jarg1;
33634   {
33635     try {
33636       result = ((Dali::Stage const *)arg1)->GetRootLayer();
33637     } catch (std::out_of_range& e) {
33638       {
33639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33640       };
33641     } catch (std::exception& e) {
33642       {
33643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33644       };
33645     } catch (...) {
33646       {
33647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33648       };
33649     }
33650   }
33651   jresult = new Dali::Layer((const Dali::Layer &)result);
33652   return jresult;
33653 }
33654
33655
33656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
33657   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33658   Dali::Vector4 arg2 ;
33659   Dali::Vector4 *argp2 ;
33660
33661   arg1 = (Dali::Stage *)jarg1;
33662   argp2 = (Dali::Vector4 *)jarg2;
33663   if (!argp2) {
33664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
33665     return ;
33666   }
33667   arg2 = *argp2;
33668   {
33669     try {
33670       (arg1)->SetBackgroundColor(arg2);
33671     } catch (std::out_of_range& e) {
33672       {
33673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33674       };
33675     } catch (std::exception& e) {
33676       {
33677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33678       };
33679     } catch (...) {
33680       {
33681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33682       };
33683     }
33684   }
33685 }
33686
33687
33688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
33689   void * jresult ;
33690   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33691   Dali::Vector4 result;
33692
33693   arg1 = (Dali::Stage *)jarg1;
33694   {
33695     try {
33696       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
33697     } catch (std::out_of_range& e) {
33698       {
33699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33700       };
33701     } catch (std::exception& e) {
33702       {
33703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33704       };
33705     } catch (...) {
33706       {
33707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33708       };
33709     }
33710   }
33711   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
33712   return jresult;
33713 }
33714
33715
33716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
33717   void * jresult ;
33718   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33719   Dali::Vector2 result;
33720
33721   arg1 = (Dali::Stage *)jarg1;
33722   {
33723     try {
33724       result = ((Dali::Stage const *)arg1)->GetDpi();
33725     } catch (std::out_of_range& e) {
33726       {
33727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33728       };
33729     } catch (std::exception& e) {
33730       {
33731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33732       };
33733     } catch (...) {
33734       {
33735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33736       };
33737     }
33738   }
33739   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33740   return jresult;
33741 }
33742
33743
33744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
33745   void * jresult ;
33746   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33747   Dali::ObjectRegistry result;
33748
33749   arg1 = (Dali::Stage *)jarg1;
33750   {
33751     try {
33752       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
33753     } catch (std::out_of_range& e) {
33754       {
33755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33756       };
33757     } catch (std::exception& e) {
33758       {
33759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33760       };
33761     } catch (...) {
33762       {
33763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33764       };
33765     }
33766   }
33767   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
33768   return jresult;
33769 }
33770
33771
33772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
33773   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33774   float arg2 ;
33775
33776   arg1 = (Dali::Stage *)jarg1;
33777   arg2 = (float)jarg2;
33778   {
33779     try {
33780       (arg1)->KeepRendering(arg2);
33781     } catch (std::out_of_range& e) {
33782       {
33783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33784       };
33785     } catch (std::exception& e) {
33786       {
33787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33788       };
33789     } catch (...) {
33790       {
33791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33792       };
33793     }
33794   }
33795 }
33796
33797
33798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
33799   void * jresult ;
33800   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33801   Dali::Stage::KeyEventSignalType *result = 0 ;
33802
33803   arg1 = (Dali::Stage *)jarg1;
33804   {
33805     try {
33806       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
33807     } catch (std::out_of_range& e) {
33808       {
33809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33810       };
33811     } catch (std::exception& e) {
33812       {
33813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33814       };
33815     } catch (...) {
33816       {
33817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33818       };
33819     }
33820   }
33821   jresult = (void *)result;
33822   return jresult;
33823 }
33824
33825
33826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
33827   void * jresult ;
33828   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33829   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
33830
33831   arg1 = (Dali::Stage *)jarg1;
33832   {
33833     try {
33834       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
33835     } catch (std::out_of_range& e) {
33836       {
33837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33838       };
33839     } catch (std::exception& e) {
33840       {
33841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33842       };
33843     } catch (...) {
33844       {
33845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33846       };
33847     }
33848   }
33849   jresult = (void *)result;
33850   return jresult;
33851 }
33852
33853
33854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
33855   void * jresult ;
33856   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33857   Dali::Stage::TouchSignalType *result = 0 ;
33858
33859   arg1 = (Dali::Stage *)jarg1;
33860   {
33861     try {
33862       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
33863     } catch (std::out_of_range& e) {
33864       {
33865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33866       };
33867     } catch (std::exception& e) {
33868       {
33869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33870       };
33871     } catch (...) {
33872       {
33873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33874       };
33875     }
33876   }
33877   jresult = (void *)result;
33878   return jresult;
33879 }
33880
33881
33882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
33883   void * jresult ;
33884   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33885   Dali::Stage::WheelEventSignalType *result = 0 ;
33886
33887   arg1 = (Dali::Stage *)jarg1;
33888   {
33889     try {
33890       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
33891     } catch (std::out_of_range& e) {
33892       {
33893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33894       };
33895     } catch (std::exception& e) {
33896       {
33897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33898       };
33899     } catch (...) {
33900       {
33901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33902       };
33903     }
33904   }
33905   jresult = (void *)result;
33906   return jresult;
33907 }
33908
33909
33910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
33911   void * jresult ;
33912   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33913   Dali::Stage::ContextStatusSignal *result = 0 ;
33914
33915   arg1 = (Dali::Stage *)jarg1;
33916   {
33917     try {
33918       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
33919     } catch (std::out_of_range& e) {
33920       {
33921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33922       };
33923     } catch (std::exception& e) {
33924       {
33925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33926       };
33927     } catch (...) {
33928       {
33929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33930       };
33931     }
33932   }
33933   jresult = (void *)result;
33934   return jresult;
33935 }
33936
33937
33938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
33939   void * jresult ;
33940   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33941   Dali::Stage::ContextStatusSignal *result = 0 ;
33942
33943   arg1 = (Dali::Stage *)jarg1;
33944   {
33945     try {
33946       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
33947     } catch (std::out_of_range& e) {
33948       {
33949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33950       };
33951     } catch (std::exception& e) {
33952       {
33953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33954       };
33955     } catch (...) {
33956       {
33957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33958       };
33959     }
33960   }
33961   jresult = (void *)result;
33962   return jresult;
33963 }
33964
33965
33966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
33967   void * jresult ;
33968   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33969   Dali::Stage::SceneCreatedSignalType *result = 0 ;
33970
33971   arg1 = (Dali::Stage *)jarg1;
33972   {
33973     try {
33974       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
33975     } catch (std::out_of_range& e) {
33976       {
33977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33978       };
33979     } catch (std::exception& e) {
33980       {
33981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33982       };
33983     } catch (...) {
33984       {
33985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33986       };
33987     }
33988   }
33989   jresult = (void *)result;
33990   return jresult;
33991 }
33992
33993
33994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
33995   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
33996
33997   arg1 = (Dali::RelayoutContainer *)jarg1;
33998   {
33999     try {
34000       delete arg1;
34001     } catch (std::out_of_range& e) {
34002       {
34003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34004       };
34005     } catch (std::exception& e) {
34006       {
34007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34008       };
34009     } catch (...) {
34010       {
34011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34012       };
34013     }
34014   }
34015 }
34016
34017
34018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
34019   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34020   Dali::Actor *arg2 = 0 ;
34021   Dali::Vector2 *arg3 = 0 ;
34022
34023   arg1 = (Dali::RelayoutContainer *)jarg1;
34024   arg2 = (Dali::Actor *)jarg2;
34025   if (!arg2) {
34026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34027     return ;
34028   }
34029   arg3 = (Dali::Vector2 *)jarg3;
34030   if (!arg3) {
34031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34032     return ;
34033   }
34034   {
34035     try {
34036       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
34037     } catch (std::out_of_range& e) {
34038       {
34039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34040       };
34041     } catch (std::exception& e) {
34042       {
34043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34044       };
34045     } catch (...) {
34046       {
34047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34048       };
34049     }
34050   }
34051 }
34052
34053
34054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
34055   void * jresult ;
34056   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34057   Dali::CustomActor result;
34058
34059   arg1 = (Dali::CustomActorImpl *)jarg1;
34060   {
34061     try {
34062       result = ((Dali::CustomActorImpl const *)arg1)->Self();
34063     } catch (std::out_of_range& e) {
34064       {
34065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34066       };
34067     } catch (std::exception& e) {
34068       {
34069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34070       };
34071     } catch (...) {
34072       {
34073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34074       };
34075     }
34076   }
34077   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34078   return jresult;
34079 }
34080
34081
34082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
34083   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34084   int arg2 ;
34085
34086   arg1 = (Dali::CustomActorImpl *)jarg1;
34087   arg2 = (int)jarg2;
34088   {
34089     try {
34090       (arg1)->OnStageConnection(arg2);
34091     } catch (std::out_of_range& e) {
34092       {
34093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34094       };
34095     } catch (std::exception& e) {
34096       {
34097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34098       };
34099     } catch (...) {
34100       {
34101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34102       };
34103     }
34104   }
34105 }
34106
34107
34108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
34109   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34110
34111   arg1 = (Dali::CustomActorImpl *)jarg1;
34112   {
34113     try {
34114       (arg1)->OnStageDisconnection();
34115     } catch (std::out_of_range& e) {
34116       {
34117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34118       };
34119     } catch (std::exception& e) {
34120       {
34121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34122       };
34123     } catch (...) {
34124       {
34125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34126       };
34127     }
34128   }
34129 }
34130
34131
34132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
34133   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34134   Dali::Actor *arg2 = 0 ;
34135
34136   arg1 = (Dali::CustomActorImpl *)jarg1;
34137   arg2 = (Dali::Actor *)jarg2;
34138   if (!arg2) {
34139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34140     return ;
34141   }
34142   {
34143     try {
34144       (arg1)->OnChildAdd(*arg2);
34145     } catch (std::out_of_range& e) {
34146       {
34147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34148       };
34149     } catch (std::exception& e) {
34150       {
34151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34152       };
34153     } catch (...) {
34154       {
34155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34156       };
34157     }
34158   }
34159 }
34160
34161
34162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
34163   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34164   Dali::Actor *arg2 = 0 ;
34165
34166   arg1 = (Dali::CustomActorImpl *)jarg1;
34167   arg2 = (Dali::Actor *)jarg2;
34168   if (!arg2) {
34169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34170     return ;
34171   }
34172   {
34173     try {
34174       (arg1)->OnChildRemove(*arg2);
34175     } catch (std::out_of_range& e) {
34176       {
34177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34178       };
34179     } catch (std::exception& e) {
34180       {
34181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34182       };
34183     } catch (...) {
34184       {
34185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34186       };
34187     }
34188   }
34189 }
34190
34191
34192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
34193   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34194   Dali::Property::Index arg2 ;
34195   Dali::Property::Value arg3 ;
34196   Dali::Property::Value *argp3 ;
34197
34198   arg1 = (Dali::CustomActorImpl *)jarg1;
34199   arg2 = (Dali::Property::Index)jarg2;
34200   argp3 = (Dali::Property::Value *)jarg3;
34201   if (!argp3) {
34202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
34203     return ;
34204   }
34205   arg3 = *argp3;
34206   {
34207     try {
34208       (arg1)->OnPropertySet(arg2,arg3);
34209     } catch (std::out_of_range& e) {
34210       {
34211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34212       };
34213     } catch (std::exception& e) {
34214       {
34215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34216       };
34217     } catch (...) {
34218       {
34219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34220       };
34221     }
34222   }
34223 }
34224
34225
34226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
34227   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34228   Dali::Vector3 *arg2 = 0 ;
34229
34230   arg1 = (Dali::CustomActorImpl *)jarg1;
34231   arg2 = (Dali::Vector3 *)jarg2;
34232   if (!arg2) {
34233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34234     return ;
34235   }
34236   {
34237     try {
34238       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
34239     } catch (std::out_of_range& e) {
34240       {
34241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34242       };
34243     } catch (std::exception& e) {
34244       {
34245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34246       };
34247     } catch (...) {
34248       {
34249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34250       };
34251     }
34252   }
34253 }
34254
34255
34256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
34257   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34258   Dali::Animation *arg2 = 0 ;
34259   Dali::Vector3 *arg3 = 0 ;
34260
34261   arg1 = (Dali::CustomActorImpl *)jarg1;
34262   arg2 = (Dali::Animation *)jarg2;
34263   if (!arg2) {
34264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
34265     return ;
34266   }
34267   arg3 = (Dali::Vector3 *)jarg3;
34268   if (!arg3) {
34269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34270     return ;
34271   }
34272   {
34273     try {
34274       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
34275     } catch (std::out_of_range& e) {
34276       {
34277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34278       };
34279     } catch (std::exception& e) {
34280       {
34281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34282       };
34283     } catch (...) {
34284       {
34285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34286       };
34287     }
34288   }
34289 }
34290
34291
34292 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
34293   unsigned int jresult ;
34294   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34295   Dali::TouchEvent *arg2 = 0 ;
34296   bool result;
34297
34298   arg1 = (Dali::CustomActorImpl *)jarg1;
34299   arg2 = (Dali::TouchEvent *)jarg2;
34300   if (!arg2) {
34301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
34302     return 0;
34303   }
34304   {
34305     try {
34306       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
34307     } catch (std::out_of_range& e) {
34308       {
34309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34310       };
34311     } catch (std::exception& e) {
34312       {
34313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34314       };
34315     } catch (...) {
34316       {
34317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34318       };
34319     }
34320   }
34321   jresult = result;
34322   return jresult;
34323 }
34324
34325
34326 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
34327   unsigned int jresult ;
34328   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34329   Dali::HoverEvent *arg2 = 0 ;
34330   bool result;
34331
34332   arg1 = (Dali::CustomActorImpl *)jarg1;
34333   arg2 = (Dali::HoverEvent *)jarg2;
34334   if (!arg2) {
34335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
34336     return 0;
34337   }
34338   {
34339     try {
34340       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
34341     } catch (std::out_of_range& e) {
34342       {
34343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34344       };
34345     } catch (std::exception& e) {
34346       {
34347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34348       };
34349     } catch (...) {
34350       {
34351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34352       };
34353     }
34354   }
34355   jresult = result;
34356   return jresult;
34357 }
34358
34359
34360 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
34361   unsigned int jresult ;
34362   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34363   Dali::KeyEvent *arg2 = 0 ;
34364   bool result;
34365
34366   arg1 = (Dali::CustomActorImpl *)jarg1;
34367   arg2 = (Dali::KeyEvent *)jarg2;
34368   if (!arg2) {
34369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
34370     return 0;
34371   }
34372   {
34373     try {
34374       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
34375     } catch (std::out_of_range& e) {
34376       {
34377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34378       };
34379     } catch (std::exception& e) {
34380       {
34381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34382       };
34383     } catch (...) {
34384       {
34385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34386       };
34387     }
34388   }
34389   jresult = result;
34390   return jresult;
34391 }
34392
34393
34394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
34395   unsigned int jresult ;
34396   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34397   Dali::WheelEvent *arg2 = 0 ;
34398   bool result;
34399
34400   arg1 = (Dali::CustomActorImpl *)jarg1;
34401   arg2 = (Dali::WheelEvent *)jarg2;
34402   if (!arg2) {
34403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
34404     return 0;
34405   }
34406   {
34407     try {
34408       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
34409     } catch (std::out_of_range& e) {
34410       {
34411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34412       };
34413     } catch (std::exception& e) {
34414       {
34415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34416       };
34417     } catch (...) {
34418       {
34419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34420       };
34421     }
34422   }
34423   jresult = result;
34424   return jresult;
34425 }
34426
34427
34428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
34429   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34430   Dali::Vector2 *arg2 = 0 ;
34431   Dali::RelayoutContainer *arg3 = 0 ;
34432
34433   arg1 = (Dali::CustomActorImpl *)jarg1;
34434   arg2 = (Dali::Vector2 *)jarg2;
34435   if (!arg2) {
34436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34437     return ;
34438   }
34439   arg3 = (Dali::RelayoutContainer *)jarg3;
34440   if (!arg3) {
34441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
34442     return ;
34443   }
34444   {
34445     try {
34446       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
34447     } catch (std::out_of_range& e) {
34448       {
34449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34450       };
34451     } catch (std::exception& e) {
34452       {
34453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34454       };
34455     } catch (...) {
34456       {
34457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34458       };
34459     }
34460   }
34461 }
34462
34463
34464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
34465   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34466   Dali::ResizePolicy::Type arg2 ;
34467   Dali::Dimension::Type arg3 ;
34468
34469   arg1 = (Dali::CustomActorImpl *)jarg1;
34470   arg2 = (Dali::ResizePolicy::Type)jarg2;
34471   arg3 = (Dali::Dimension::Type)jarg3;
34472   {
34473     try {
34474       (arg1)->OnSetResizePolicy(arg2,arg3);
34475     } catch (std::out_of_range& e) {
34476       {
34477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34478       };
34479     } catch (std::exception& e) {
34480       {
34481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34482       };
34483     } catch (...) {
34484       {
34485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34486       };
34487     }
34488   }
34489 }
34490
34491
34492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
34493   void * jresult ;
34494   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34495   Dali::Vector3 result;
34496
34497   arg1 = (Dali::CustomActorImpl *)jarg1;
34498   {
34499     try {
34500       result = (arg1)->GetNaturalSize();
34501     } catch (std::out_of_range& e) {
34502       {
34503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34504       };
34505     } catch (std::exception& e) {
34506       {
34507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34508       };
34509     } catch (...) {
34510       {
34511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34512       };
34513     }
34514   }
34515   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34516   return jresult;
34517 }
34518
34519
34520 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
34521   float jresult ;
34522   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34523   Dali::Actor *arg2 = 0 ;
34524   Dali::Dimension::Type arg3 ;
34525   float result;
34526
34527   arg1 = (Dali::CustomActorImpl *)jarg1;
34528   arg2 = (Dali::Actor *)jarg2;
34529   if (!arg2) {
34530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34531     return 0;
34532   }
34533   arg3 = (Dali::Dimension::Type)jarg3;
34534   {
34535     try {
34536       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
34537     } catch (std::out_of_range& e) {
34538       {
34539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34540       };
34541     } catch (std::exception& e) {
34542       {
34543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34544       };
34545     } catch (...) {
34546       {
34547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34548       };
34549     }
34550   }
34551   jresult = result;
34552   return jresult;
34553 }
34554
34555
34556 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
34557   float jresult ;
34558   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34559   float arg2 ;
34560   float result;
34561
34562   arg1 = (Dali::CustomActorImpl *)jarg1;
34563   arg2 = (float)jarg2;
34564   {
34565     try {
34566       result = (float)(arg1)->GetHeightForWidth(arg2);
34567     } catch (std::out_of_range& e) {
34568       {
34569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34570       };
34571     } catch (std::exception& e) {
34572       {
34573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34574       };
34575     } catch (...) {
34576       {
34577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34578       };
34579     }
34580   }
34581   jresult = result;
34582   return jresult;
34583 }
34584
34585
34586 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
34587   float jresult ;
34588   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34589   float arg2 ;
34590   float result;
34591
34592   arg1 = (Dali::CustomActorImpl *)jarg1;
34593   arg2 = (float)jarg2;
34594   {
34595     try {
34596       result = (float)(arg1)->GetWidthForHeight(arg2);
34597     } catch (std::out_of_range& e) {
34598       {
34599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34600       };
34601     } catch (std::exception& e) {
34602       {
34603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34604       };
34605     } catch (...) {
34606       {
34607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34608       };
34609     }
34610   }
34611   jresult = result;
34612   return jresult;
34613 }
34614
34615
34616 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
34617   unsigned int jresult ;
34618   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34619   Dali::Dimension::Type arg2 ;
34620   bool result;
34621
34622   arg1 = (Dali::CustomActorImpl *)jarg1;
34623   arg2 = (Dali::Dimension::Type)jarg2;
34624   {
34625     try {
34626       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
34627     } catch (std::out_of_range& e) {
34628       {
34629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34630       };
34631     } catch (std::exception& e) {
34632       {
34633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34634       };
34635     } catch (...) {
34636       {
34637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34638       };
34639     }
34640   }
34641   jresult = result;
34642   return jresult;
34643 }
34644
34645
34646 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
34647   unsigned int jresult ;
34648   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34649   bool result;
34650
34651   arg1 = (Dali::CustomActorImpl *)jarg1;
34652   {
34653     try {
34654       result = (bool)(arg1)->RelayoutDependentOnChildren();
34655     } catch (std::out_of_range& e) {
34656       {
34657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34658       };
34659     } catch (std::exception& e) {
34660       {
34661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34662       };
34663     } catch (...) {
34664       {
34665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34666       };
34667     }
34668   }
34669   jresult = result;
34670   return jresult;
34671 }
34672
34673
34674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
34675   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34676   Dali::Dimension::Type arg2 ;
34677
34678   arg1 = (Dali::CustomActorImpl *)jarg1;
34679   arg2 = (Dali::Dimension::Type)jarg2;
34680   {
34681     try {
34682       (arg1)->OnCalculateRelayoutSize(arg2);
34683     } catch (std::out_of_range& e) {
34684       {
34685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34686       };
34687     } catch (std::exception& e) {
34688       {
34689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34690       };
34691     } catch (...) {
34692       {
34693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34694       };
34695     }
34696   }
34697 }
34698
34699
34700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
34701   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34702   float arg2 ;
34703   Dali::Dimension::Type arg3 ;
34704
34705   arg1 = (Dali::CustomActorImpl *)jarg1;
34706   arg2 = (float)jarg2;
34707   arg3 = (Dali::Dimension::Type)jarg3;
34708   {
34709     try {
34710       (arg1)->OnLayoutNegotiated(arg2,arg3);
34711     } catch (std::out_of_range& e) {
34712       {
34713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34714       };
34715     } catch (std::exception& e) {
34716       {
34717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34718       };
34719     } catch (...) {
34720       {
34721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34722       };
34723     }
34724   }
34725 }
34726
34727
34728 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
34729   unsigned int jresult ;
34730   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34731   bool result;
34732
34733   arg1 = (Dali::CustomActorImpl *)jarg1;
34734   {
34735     try {
34736       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
34737     } catch (std::out_of_range& e) {
34738       {
34739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34740       };
34741     } catch (std::exception& e) {
34742       {
34743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34744       };
34745     } catch (...) {
34746       {
34747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34748       };
34749     }
34750   }
34751   jresult = result;
34752   return jresult;
34753 }
34754
34755
34756 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
34757   unsigned int jresult ;
34758   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34759   bool result;
34760
34761   arg1 = (Dali::CustomActorImpl *)jarg1;
34762   {
34763     try {
34764       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
34765     } catch (std::out_of_range& e) {
34766       {
34767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34768       };
34769     } catch (std::exception& e) {
34770       {
34771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34772       };
34773     } catch (...) {
34774       {
34775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34776       };
34777     }
34778   }
34779   jresult = result;
34780   return jresult;
34781 }
34782
34783
34784 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
34785   unsigned int jresult ;
34786   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34787   bool result;
34788
34789   arg1 = (Dali::CustomActorImpl *)jarg1;
34790   {
34791     try {
34792       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
34793     } catch (std::out_of_range& e) {
34794       {
34795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34796       };
34797     } catch (std::exception& e) {
34798       {
34799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34800       };
34801     } catch (...) {
34802       {
34803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34804       };
34805     }
34806   }
34807   jresult = result;
34808   return jresult;
34809 }
34810
34811
34812 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
34813   unsigned int jresult ;
34814   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34815   bool result;
34816
34817   arg1 = (Dali::CustomActorImpl *)jarg1;
34818   {
34819     try {
34820       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
34821     } catch (std::out_of_range& e) {
34822       {
34823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34824       };
34825     } catch (std::exception& e) {
34826       {
34827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34828       };
34829     } catch (...) {
34830       {
34831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34832       };
34833     }
34834   }
34835   jresult = result;
34836   return jresult;
34837 }
34838
34839
34840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
34841   void * jresult ;
34842   Dali::CustomActor *result = 0 ;
34843
34844   {
34845     try {
34846       result = (Dali::CustomActor *)new Dali::CustomActor();
34847     } catch (std::out_of_range& e) {
34848       {
34849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34850       };
34851     } catch (std::exception& e) {
34852       {
34853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34854       };
34855     } catch (...) {
34856       {
34857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34858       };
34859     }
34860   }
34861   jresult = (void *)result;
34862   return jresult;
34863 }
34864
34865
34866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
34867   void * jresult ;
34868   Dali::BaseHandle arg1 ;
34869   Dali::BaseHandle *argp1 ;
34870   Dali::CustomActor result;
34871
34872   argp1 = (Dali::BaseHandle *)jarg1;
34873   if (!argp1) {
34874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
34875     return 0;
34876   }
34877   arg1 = *argp1;
34878   {
34879     try {
34880       result = Dali::CustomActor::DownCast(arg1);
34881     } catch (std::out_of_range& e) {
34882       {
34883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34884       };
34885     } catch (std::exception& e) {
34886       {
34887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34888       };
34889     } catch (...) {
34890       {
34891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34892       };
34893     }
34894   }
34895   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34896   return jresult;
34897 }
34898
34899
34900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
34901   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
34902
34903   arg1 = (Dali::CustomActor *)jarg1;
34904   {
34905     try {
34906       delete arg1;
34907     } catch (std::out_of_range& e) {
34908       {
34909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34910       };
34911     } catch (std::exception& e) {
34912       {
34913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34914       };
34915     } catch (...) {
34916       {
34917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34918       };
34919     }
34920   }
34921 }
34922
34923
34924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
34925   void * jresult ;
34926   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
34927   Dali::CustomActorImpl *result = 0 ;
34928
34929   arg1 = (Dali::CustomActor *)jarg1;
34930   {
34931     try {
34932       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
34933     } catch (std::out_of_range& e) {
34934       {
34935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34936       };
34937     } catch (std::exception& e) {
34938       {
34939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34940       };
34941     } catch (...) {
34942       {
34943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34944       };
34945     }
34946   }
34947   jresult = (void *)result;
34948   return jresult;
34949 }
34950
34951
34952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
34953   void * jresult ;
34954   Dali::CustomActorImpl *arg1 = 0 ;
34955   Dali::CustomActor *result = 0 ;
34956
34957   arg1 = (Dali::CustomActorImpl *)jarg1;
34958   if (!arg1) {
34959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
34960     return 0;
34961   }
34962   {
34963     try {
34964       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
34965     } catch (std::out_of_range& e) {
34966       {
34967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34968       };
34969     } catch (std::exception& e) {
34970       {
34971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34972       };
34973     } catch (...) {
34974       {
34975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34976       };
34977     }
34978   }
34979   jresult = (void *)result;
34980   return jresult;
34981 }
34982
34983
34984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
34985   void * jresult ;
34986   Dali::CustomActor *arg1 = 0 ;
34987   Dali::CustomActor *result = 0 ;
34988
34989   arg1 = (Dali::CustomActor *)jarg1;
34990   if (!arg1) {
34991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
34992     return 0;
34993   }
34994   {
34995     try {
34996       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
34997     } catch (std::out_of_range& e) {
34998       {
34999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35000       };
35001     } catch (std::exception& e) {
35002       {
35003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35004       };
35005     } catch (...) {
35006       {
35007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35008       };
35009     }
35010   }
35011   jresult = (void *)result;
35012   return jresult;
35013 }
35014
35015
35016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
35017   void * jresult ;
35018   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35019   Dali::CustomActor *arg2 = 0 ;
35020   Dali::CustomActor *result = 0 ;
35021
35022   arg1 = (Dali::CustomActor *)jarg1;
35023   arg2 = (Dali::CustomActor *)jarg2;
35024   if (!arg2) {
35025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35026     return 0;
35027   }
35028   {
35029     try {
35030       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
35031     } catch (std::out_of_range& e) {
35032       {
35033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35034       };
35035     } catch (std::exception& e) {
35036       {
35037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35038       };
35039     } catch (...) {
35040       {
35041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35042       };
35043     }
35044   }
35045   jresult = (void *)result;
35046   return jresult;
35047 }
35048
35049
35050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
35051   int jresult ;
35052   int result;
35053
35054   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
35055   jresult = (int)result;
35056   return jresult;
35057 }
35058
35059
35060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
35061   int jresult ;
35062   int result;
35063
35064   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
35065   jresult = (int)result;
35066   return jresult;
35067 }
35068
35069
35070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
35071   int jresult ;
35072   int result;
35073
35074   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
35075   jresult = (int)result;
35076   return jresult;
35077 }
35078
35079
35080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
35081   int jresult ;
35082   int result;
35083
35084   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
35085   jresult = (int)result;
35086   return jresult;
35087 }
35088
35089
35090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
35091   int jresult ;
35092   int result;
35093
35094   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
35095   jresult = (int)result;
35096   return jresult;
35097 }
35098
35099
35100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
35101   int jresult ;
35102   int result;
35103
35104   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
35105   jresult = (int)result;
35106   return jresult;
35107 }
35108
35109
35110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
35111   int jresult ;
35112   int result;
35113
35114   result = (int)Dali::PanGestureDetector::Property::PANNING;
35115   jresult = (int)result;
35116   return jresult;
35117 }
35118
35119
35120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
35121   void * jresult ;
35122   Dali::PanGestureDetector::Property *result = 0 ;
35123
35124   {
35125     try {
35126       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
35127     } catch (std::out_of_range& e) {
35128       {
35129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35130       };
35131     } catch (std::exception& e) {
35132       {
35133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35134       };
35135     } catch (...) {
35136       {
35137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35138       };
35139     }
35140   }
35141   jresult = (void *)result;
35142   return jresult;
35143 }
35144
35145
35146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
35147   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
35148
35149   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
35150   {
35151     try {
35152       delete arg1;
35153     } catch (std::out_of_range& e) {
35154       {
35155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35156       };
35157     } catch (std::exception& e) {
35158       {
35159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35160       };
35161     } catch (...) {
35162       {
35163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35164       };
35165     }
35166   }
35167 }
35168
35169
35170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
35171   void * jresult ;
35172   Dali::Radian *result = 0 ;
35173
35174   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
35175   jresult = (void *)result;
35176   return jresult;
35177 }
35178
35179
35180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
35181   void * jresult ;
35182   Dali::Radian *result = 0 ;
35183
35184   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
35185   jresult = (void *)result;
35186   return jresult;
35187 }
35188
35189
35190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
35191   void * jresult ;
35192   Dali::Radian *result = 0 ;
35193
35194   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
35195   jresult = (void *)result;
35196   return jresult;
35197 }
35198
35199
35200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
35201   void * jresult ;
35202   Dali::Radian *result = 0 ;
35203
35204   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
35205   jresult = (void *)result;
35206   return jresult;
35207 }
35208
35209
35210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
35211   void * jresult ;
35212   Dali::Radian *result = 0 ;
35213
35214   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
35215   jresult = (void *)result;
35216   return jresult;
35217 }
35218
35219
35220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
35221   void * jresult ;
35222   Dali::Radian *result = 0 ;
35223
35224   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
35225   jresult = (void *)result;
35226   return jresult;
35227 }
35228
35229
35230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
35231   void * jresult ;
35232   Dali::Radian *result = 0 ;
35233
35234   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
35235   jresult = (void *)result;
35236   return jresult;
35237 }
35238
35239
35240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
35241   void * jresult ;
35242   Dali::PanGestureDetector *result = 0 ;
35243
35244   {
35245     try {
35246       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
35247     } catch (std::out_of_range& e) {
35248       {
35249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35250       };
35251     } catch (std::exception& e) {
35252       {
35253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35254       };
35255     } catch (...) {
35256       {
35257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35258       };
35259     }
35260   }
35261   jresult = (void *)result;
35262   return jresult;
35263 }
35264
35265
35266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
35267   void * jresult ;
35268   Dali::PanGestureDetector result;
35269
35270   {
35271     try {
35272       result = Dali::PanGestureDetector::New();
35273     } catch (std::out_of_range& e) {
35274       {
35275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35276       };
35277     } catch (std::exception& e) {
35278       {
35279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35280       };
35281     } catch (...) {
35282       {
35283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35284       };
35285     }
35286   }
35287   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35288   return jresult;
35289 }
35290
35291
35292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
35293   void * jresult ;
35294   Dali::BaseHandle arg1 ;
35295   Dali::BaseHandle *argp1 ;
35296   Dali::PanGestureDetector result;
35297
35298   argp1 = (Dali::BaseHandle *)jarg1;
35299   if (!argp1) {
35300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35301     return 0;
35302   }
35303   arg1 = *argp1;
35304   {
35305     try {
35306       result = Dali::PanGestureDetector::DownCast(arg1);
35307     } catch (std::out_of_range& e) {
35308       {
35309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35310       };
35311     } catch (std::exception& e) {
35312       {
35313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35314       };
35315     } catch (...) {
35316       {
35317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35318       };
35319     }
35320   }
35321   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35322   return jresult;
35323 }
35324
35325
35326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
35327   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35328
35329   arg1 = (Dali::PanGestureDetector *)jarg1;
35330   {
35331     try {
35332       delete arg1;
35333     } catch (std::out_of_range& e) {
35334       {
35335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35336       };
35337     } catch (std::exception& e) {
35338       {
35339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35340       };
35341     } catch (...) {
35342       {
35343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35344       };
35345     }
35346   }
35347 }
35348
35349
35350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
35351   void * jresult ;
35352   Dali::PanGestureDetector *arg1 = 0 ;
35353   Dali::PanGestureDetector *result = 0 ;
35354
35355   arg1 = (Dali::PanGestureDetector *)jarg1;
35356   if (!arg1) {
35357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35358     return 0;
35359   }
35360   {
35361     try {
35362       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
35363     } catch (std::out_of_range& e) {
35364       {
35365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35366       };
35367     } catch (std::exception& e) {
35368       {
35369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35370       };
35371     } catch (...) {
35372       {
35373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35374       };
35375     }
35376   }
35377   jresult = (void *)result;
35378   return jresult;
35379 }
35380
35381
35382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
35383   void * jresult ;
35384   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35385   Dali::PanGestureDetector *arg2 = 0 ;
35386   Dali::PanGestureDetector *result = 0 ;
35387
35388   arg1 = (Dali::PanGestureDetector *)jarg1;
35389   arg2 = (Dali::PanGestureDetector *)jarg2;
35390   if (!arg2) {
35391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35392     return 0;
35393   }
35394   {
35395     try {
35396       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
35397     } catch (std::out_of_range& e) {
35398       {
35399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35400       };
35401     } catch (std::exception& e) {
35402       {
35403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35404       };
35405     } catch (...) {
35406       {
35407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35408       };
35409     }
35410   }
35411   jresult = (void *)result;
35412   return jresult;
35413 }
35414
35415
35416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
35417   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35418   unsigned int arg2 ;
35419
35420   arg1 = (Dali::PanGestureDetector *)jarg1;
35421   arg2 = (unsigned int)jarg2;
35422   {
35423     try {
35424       (arg1)->SetMinimumTouchesRequired(arg2);
35425     } catch (std::out_of_range& e) {
35426       {
35427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35428       };
35429     } catch (std::exception& e) {
35430       {
35431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35432       };
35433     } catch (...) {
35434       {
35435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35436       };
35437     }
35438   }
35439 }
35440
35441
35442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
35443   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35444   unsigned int arg2 ;
35445
35446   arg1 = (Dali::PanGestureDetector *)jarg1;
35447   arg2 = (unsigned int)jarg2;
35448   {
35449     try {
35450       (arg1)->SetMaximumTouchesRequired(arg2);
35451     } catch (std::out_of_range& e) {
35452       {
35453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35454       };
35455     } catch (std::exception& e) {
35456       {
35457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35458       };
35459     } catch (...) {
35460       {
35461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35462       };
35463     }
35464   }
35465 }
35466
35467
35468 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
35469   unsigned int jresult ;
35470   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35471   unsigned int result;
35472
35473   arg1 = (Dali::PanGestureDetector *)jarg1;
35474   {
35475     try {
35476       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
35477     } catch (std::out_of_range& e) {
35478       {
35479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35480       };
35481     } catch (std::exception& e) {
35482       {
35483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35484       };
35485     } catch (...) {
35486       {
35487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35488       };
35489     }
35490   }
35491   jresult = result;
35492   return jresult;
35493 }
35494
35495
35496 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
35497   unsigned int jresult ;
35498   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35499   unsigned int result;
35500
35501   arg1 = (Dali::PanGestureDetector *)jarg1;
35502   {
35503     try {
35504       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
35505     } catch (std::out_of_range& e) {
35506       {
35507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35508       };
35509     } catch (std::exception& e) {
35510       {
35511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35512       };
35513     } catch (...) {
35514       {
35515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35516       };
35517     }
35518   }
35519   jresult = result;
35520   return jresult;
35521 }
35522
35523
35524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35525   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35526   Dali::Radian arg2 ;
35527   Dali::Radian arg3 ;
35528   Dali::Radian *argp2 ;
35529   Dali::Radian *argp3 ;
35530
35531   arg1 = (Dali::PanGestureDetector *)jarg1;
35532   argp2 = (Dali::Radian *)jarg2;
35533   if (!argp2) {
35534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35535     return ;
35536   }
35537   arg2 = *argp2;
35538   argp3 = (Dali::Radian *)jarg3;
35539   if (!argp3) {
35540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35541     return ;
35542   }
35543   arg3 = *argp3;
35544   {
35545     try {
35546       (arg1)->AddAngle(arg2,arg3);
35547     } catch (std::out_of_range& e) {
35548       {
35549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35550       };
35551     } catch (std::exception& e) {
35552       {
35553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35554       };
35555     } catch (...) {
35556       {
35557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35558       };
35559     }
35560   }
35561 }
35562
35563
35564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
35565   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35566   Dali::Radian arg2 ;
35567   Dali::Radian *argp2 ;
35568
35569   arg1 = (Dali::PanGestureDetector *)jarg1;
35570   argp2 = (Dali::Radian *)jarg2;
35571   if (!argp2) {
35572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35573     return ;
35574   }
35575   arg2 = *argp2;
35576   {
35577     try {
35578       (arg1)->AddAngle(arg2);
35579     } catch (std::out_of_range& e) {
35580       {
35581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35582       };
35583     } catch (std::exception& e) {
35584       {
35585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35586       };
35587     } catch (...) {
35588       {
35589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35590       };
35591     }
35592   }
35593 }
35594
35595
35596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35597   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35598   Dali::Radian arg2 ;
35599   Dali::Radian arg3 ;
35600   Dali::Radian *argp2 ;
35601   Dali::Radian *argp3 ;
35602
35603   arg1 = (Dali::PanGestureDetector *)jarg1;
35604   argp2 = (Dali::Radian *)jarg2;
35605   if (!argp2) {
35606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35607     return ;
35608   }
35609   arg2 = *argp2;
35610   argp3 = (Dali::Radian *)jarg3;
35611   if (!argp3) {
35612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35613     return ;
35614   }
35615   arg3 = *argp3;
35616   {
35617     try {
35618       (arg1)->AddDirection(arg2,arg3);
35619     } catch (std::out_of_range& e) {
35620       {
35621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35622       };
35623     } catch (std::exception& e) {
35624       {
35625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35626       };
35627     } catch (...) {
35628       {
35629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35630       };
35631     }
35632   }
35633 }
35634
35635
35636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
35637   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35638   Dali::Radian arg2 ;
35639   Dali::Radian *argp2 ;
35640
35641   arg1 = (Dali::PanGestureDetector *)jarg1;
35642   argp2 = (Dali::Radian *)jarg2;
35643   if (!argp2) {
35644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35645     return ;
35646   }
35647   arg2 = *argp2;
35648   {
35649     try {
35650       (arg1)->AddDirection(arg2);
35651     } catch (std::out_of_range& e) {
35652       {
35653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35654       };
35655     } catch (std::exception& e) {
35656       {
35657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35658       };
35659     } catch (...) {
35660       {
35661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35662       };
35663     }
35664   }
35665 }
35666
35667
35668 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
35669   unsigned long jresult ;
35670   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35671   size_t result;
35672
35673   arg1 = (Dali::PanGestureDetector *)jarg1;
35674   {
35675     try {
35676       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
35677     } catch (std::out_of_range& e) {
35678       {
35679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35680       };
35681     } catch (std::exception& e) {
35682       {
35683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35684       };
35685     } catch (...) {
35686       {
35687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35688       };
35689     }
35690   }
35691   jresult = (unsigned long)result;
35692   return jresult;
35693 }
35694
35695
35696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
35697   void * jresult ;
35698   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35699   size_t arg2 ;
35700   Dali::PanGestureDetector::AngleThresholdPair result;
35701
35702   arg1 = (Dali::PanGestureDetector *)jarg1;
35703   arg2 = (size_t)jarg2;
35704   {
35705     try {
35706       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
35707     } catch (std::out_of_range& e) {
35708       {
35709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35710       };
35711     } catch (std::exception& e) {
35712       {
35713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35714       };
35715     } catch (...) {
35716       {
35717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35718       };
35719     }
35720   }
35721   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
35722   return jresult;
35723 }
35724
35725
35726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
35727   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35728
35729   arg1 = (Dali::PanGestureDetector *)jarg1;
35730   {
35731     try {
35732       (arg1)->ClearAngles();
35733     } catch (std::out_of_range& e) {
35734       {
35735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35736       };
35737     } catch (std::exception& e) {
35738       {
35739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35740       };
35741     } catch (...) {
35742       {
35743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35744       };
35745     }
35746   }
35747 }
35748
35749
35750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
35751   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35752   Dali::Radian arg2 ;
35753   Dali::Radian *argp2 ;
35754
35755   arg1 = (Dali::PanGestureDetector *)jarg1;
35756   argp2 = (Dali::Radian *)jarg2;
35757   if (!argp2) {
35758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35759     return ;
35760   }
35761   arg2 = *argp2;
35762   {
35763     try {
35764       (arg1)->RemoveAngle(arg2);
35765     } catch (std::out_of_range& e) {
35766       {
35767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35768       };
35769     } catch (std::exception& e) {
35770       {
35771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35772       };
35773     } catch (...) {
35774       {
35775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35776       };
35777     }
35778   }
35779 }
35780
35781
35782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
35783   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35784   Dali::Radian arg2 ;
35785   Dali::Radian *argp2 ;
35786
35787   arg1 = (Dali::PanGestureDetector *)jarg1;
35788   argp2 = (Dali::Radian *)jarg2;
35789   if (!argp2) {
35790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35791     return ;
35792   }
35793   arg2 = *argp2;
35794   {
35795     try {
35796       (arg1)->RemoveDirection(arg2);
35797     } catch (std::out_of_range& e) {
35798       {
35799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35800       };
35801     } catch (std::exception& e) {
35802       {
35803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35804       };
35805     } catch (...) {
35806       {
35807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35808       };
35809     }
35810   }
35811 }
35812
35813
35814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
35815   void * jresult ;
35816   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35817   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
35818
35819   arg1 = (Dali::PanGestureDetector *)jarg1;
35820   {
35821     try {
35822       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
35823     } catch (std::out_of_range& e) {
35824       {
35825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35826       };
35827     } catch (std::exception& e) {
35828       {
35829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35830       };
35831     } catch (...) {
35832       {
35833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35834       };
35835     }
35836   }
35837   jresult = (void *)result;
35838   return jresult;
35839 }
35840
35841
35842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
35843   Dali::PanGesture *arg1 = 0 ;
35844
35845   arg1 = (Dali::PanGesture *)jarg1;
35846   if (!arg1) {
35847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35848     return ;
35849   }
35850   {
35851     try {
35852       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
35853     } catch (std::out_of_range& e) {
35854       {
35855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35856       };
35857     } catch (std::exception& e) {
35858       {
35859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35860       };
35861     } catch (...) {
35862       {
35863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35864       };
35865     }
35866   }
35867 }
35868
35869
35870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
35871   void * jresult ;
35872   Dali::PanGesture *result = 0 ;
35873
35874   {
35875     try {
35876       result = (Dali::PanGesture *)new Dali::PanGesture();
35877     } catch (std::out_of_range& e) {
35878       {
35879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35880       };
35881     } catch (std::exception& e) {
35882       {
35883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35884       };
35885     } catch (...) {
35886       {
35887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35888       };
35889     }
35890   }
35891   jresult = (void *)result;
35892   return jresult;
35893 }
35894
35895
35896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
35897   void * jresult ;
35898   Dali::Gesture::State arg1 ;
35899   Dali::PanGesture *result = 0 ;
35900
35901   arg1 = (Dali::Gesture::State)jarg1;
35902   {
35903     try {
35904       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
35905     } catch (std::out_of_range& e) {
35906       {
35907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35908       };
35909     } catch (std::exception& e) {
35910       {
35911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35912       };
35913     } catch (...) {
35914       {
35915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35916       };
35917     }
35918   }
35919   jresult = (void *)result;
35920   return jresult;
35921 }
35922
35923
35924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
35925   void * jresult ;
35926   Dali::PanGesture *arg1 = 0 ;
35927   Dali::PanGesture *result = 0 ;
35928
35929   arg1 = (Dali::PanGesture *)jarg1;
35930   if (!arg1) {
35931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35932     return 0;
35933   }
35934   {
35935     try {
35936       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
35937     } catch (std::out_of_range& e) {
35938       {
35939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35940       };
35941     } catch (std::exception& e) {
35942       {
35943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35944       };
35945     } catch (...) {
35946       {
35947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35948       };
35949     }
35950   }
35951   jresult = (void *)result;
35952   return jresult;
35953 }
35954
35955
35956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
35957   void * jresult ;
35958   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35959   Dali::PanGesture *arg2 = 0 ;
35960   Dali::PanGesture *result = 0 ;
35961
35962   arg1 = (Dali::PanGesture *)jarg1;
35963   arg2 = (Dali::PanGesture *)jarg2;
35964   if (!arg2) {
35965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35966     return 0;
35967   }
35968   {
35969     try {
35970       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
35971     } catch (std::out_of_range& e) {
35972       {
35973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35974       };
35975     } catch (std::exception& e) {
35976       {
35977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35978       };
35979     } catch (...) {
35980       {
35981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35982       };
35983     }
35984   }
35985   jresult = (void *)result;
35986   return jresult;
35987 }
35988
35989
35990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
35991   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35992
35993   arg1 = (Dali::PanGesture *)jarg1;
35994   {
35995     try {
35996       delete arg1;
35997     } catch (std::out_of_range& e) {
35998       {
35999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36000       };
36001     } catch (std::exception& e) {
36002       {
36003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36004       };
36005     } catch (...) {
36006       {
36007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36008       };
36009     }
36010   }
36011 }
36012
36013
36014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
36015   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36016   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36017
36018   arg1 = (Dali::PanGesture *)jarg1;
36019   arg2 = (Dali::Vector2 *)jarg2;
36020   if (arg1) (arg1)->velocity = *arg2;
36021 }
36022
36023
36024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
36025   void * jresult ;
36026   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36027   Dali::Vector2 *result = 0 ;
36028
36029   arg1 = (Dali::PanGesture *)jarg1;
36030   result = (Dali::Vector2 *)& ((arg1)->velocity);
36031   jresult = (void *)result;
36032   return jresult;
36033 }
36034
36035
36036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
36037   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36038   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36039
36040   arg1 = (Dali::PanGesture *)jarg1;
36041   arg2 = (Dali::Vector2 *)jarg2;
36042   if (arg1) (arg1)->displacement = *arg2;
36043 }
36044
36045
36046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
36047   void * jresult ;
36048   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36049   Dali::Vector2 *result = 0 ;
36050
36051   arg1 = (Dali::PanGesture *)jarg1;
36052   result = (Dali::Vector2 *)& ((arg1)->displacement);
36053   jresult = (void *)result;
36054   return jresult;
36055 }
36056
36057
36058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
36059   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36060   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36061
36062   arg1 = (Dali::PanGesture *)jarg1;
36063   arg2 = (Dali::Vector2 *)jarg2;
36064   if (arg1) (arg1)->position = *arg2;
36065 }
36066
36067
36068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
36069   void * jresult ;
36070   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36071   Dali::Vector2 *result = 0 ;
36072
36073   arg1 = (Dali::PanGesture *)jarg1;
36074   result = (Dali::Vector2 *)& ((arg1)->position);
36075   jresult = (void *)result;
36076   return jresult;
36077 }
36078
36079
36080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
36081   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36082   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36083
36084   arg1 = (Dali::PanGesture *)jarg1;
36085   arg2 = (Dali::Vector2 *)jarg2;
36086   if (arg1) (arg1)->screenVelocity = *arg2;
36087 }
36088
36089
36090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
36091   void * jresult ;
36092   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36093   Dali::Vector2 *result = 0 ;
36094
36095   arg1 = (Dali::PanGesture *)jarg1;
36096   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
36097   jresult = (void *)result;
36098   return jresult;
36099 }
36100
36101
36102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
36103   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36104   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36105
36106   arg1 = (Dali::PanGesture *)jarg1;
36107   arg2 = (Dali::Vector2 *)jarg2;
36108   if (arg1) (arg1)->screenDisplacement = *arg2;
36109 }
36110
36111
36112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
36113   void * jresult ;
36114   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36115   Dali::Vector2 *result = 0 ;
36116
36117   arg1 = (Dali::PanGesture *)jarg1;
36118   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
36119   jresult = (void *)result;
36120   return jresult;
36121 }
36122
36123
36124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
36125   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36126   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36127
36128   arg1 = (Dali::PanGesture *)jarg1;
36129   arg2 = (Dali::Vector2 *)jarg2;
36130   if (arg1) (arg1)->screenPosition = *arg2;
36131 }
36132
36133
36134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
36135   void * jresult ;
36136   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36137   Dali::Vector2 *result = 0 ;
36138
36139   arg1 = (Dali::PanGesture *)jarg1;
36140   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
36141   jresult = (void *)result;
36142   return jresult;
36143 }
36144
36145
36146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
36147   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36148   unsigned int arg2 ;
36149
36150   arg1 = (Dali::PanGesture *)jarg1;
36151   arg2 = (unsigned int)jarg2;
36152   if (arg1) (arg1)->numberOfTouches = arg2;
36153 }
36154
36155
36156 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
36157   unsigned int jresult ;
36158   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36159   unsigned int result;
36160
36161   arg1 = (Dali::PanGesture *)jarg1;
36162   result = (unsigned int) ((arg1)->numberOfTouches);
36163   jresult = result;
36164   return jresult;
36165 }
36166
36167
36168 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
36169   float jresult ;
36170   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36171   float result;
36172
36173   arg1 = (Dali::PanGesture *)jarg1;
36174   {
36175     try {
36176       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
36177     } catch (std::out_of_range& e) {
36178       {
36179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36180       };
36181     } catch (std::exception& e) {
36182       {
36183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36184       };
36185     } catch (...) {
36186       {
36187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36188       };
36189     }
36190   }
36191   jresult = result;
36192   return jresult;
36193 }
36194
36195
36196 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
36197   float jresult ;
36198   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36199   float result;
36200
36201   arg1 = (Dali::PanGesture *)jarg1;
36202   {
36203     try {
36204       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
36205     } catch (std::out_of_range& e) {
36206       {
36207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36208       };
36209     } catch (std::exception& e) {
36210       {
36211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36212       };
36213     } catch (...) {
36214       {
36215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36216       };
36217     }
36218   }
36219   jresult = result;
36220   return jresult;
36221 }
36222
36223
36224 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
36225   float jresult ;
36226   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36227   float result;
36228
36229   arg1 = (Dali::PanGesture *)jarg1;
36230   {
36231     try {
36232       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
36233     } catch (std::out_of_range& e) {
36234       {
36235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36236       };
36237     } catch (std::exception& e) {
36238       {
36239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36240       };
36241     } catch (...) {
36242       {
36243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36244       };
36245     }
36246   }
36247   jresult = result;
36248   return jresult;
36249 }
36250
36251
36252 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
36253   float jresult ;
36254   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36255   float result;
36256
36257   arg1 = (Dali::PanGesture *)jarg1;
36258   {
36259     try {
36260       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
36261     } catch (std::out_of_range& e) {
36262       {
36263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36264       };
36265     } catch (std::exception& e) {
36266       {
36267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36268       };
36269     } catch (...) {
36270       {
36271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36272       };
36273     }
36274   }
36275   jresult = result;
36276   return jresult;
36277 }
36278
36279
36280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
36281   void * jresult ;
36282   Dali::PinchGestureDetector *result = 0 ;
36283
36284   {
36285     try {
36286       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
36287     } catch (std::out_of_range& e) {
36288       {
36289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36290       };
36291     } catch (std::exception& e) {
36292       {
36293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36294       };
36295     } catch (...) {
36296       {
36297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36298       };
36299     }
36300   }
36301   jresult = (void *)result;
36302   return jresult;
36303 }
36304
36305
36306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
36307   void * jresult ;
36308   Dali::PinchGestureDetector result;
36309
36310   {
36311     try {
36312       result = Dali::PinchGestureDetector::New();
36313     } catch (std::out_of_range& e) {
36314       {
36315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36316       };
36317     } catch (std::exception& e) {
36318       {
36319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36320       };
36321     } catch (...) {
36322       {
36323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36324       };
36325     }
36326   }
36327   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36328   return jresult;
36329 }
36330
36331
36332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
36333   void * jresult ;
36334   Dali::BaseHandle arg1 ;
36335   Dali::BaseHandle *argp1 ;
36336   Dali::PinchGestureDetector result;
36337
36338   argp1 = (Dali::BaseHandle *)jarg1;
36339   if (!argp1) {
36340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36341     return 0;
36342   }
36343   arg1 = *argp1;
36344   {
36345     try {
36346       result = Dali::PinchGestureDetector::DownCast(arg1);
36347     } catch (std::out_of_range& e) {
36348       {
36349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36350       };
36351     } catch (std::exception& e) {
36352       {
36353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36354       };
36355     } catch (...) {
36356       {
36357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36358       };
36359     }
36360   }
36361   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36362   return jresult;
36363 }
36364
36365
36366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
36367   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36368
36369   arg1 = (Dali::PinchGestureDetector *)jarg1;
36370   {
36371     try {
36372       delete arg1;
36373     } catch (std::out_of_range& e) {
36374       {
36375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36376       };
36377     } catch (std::exception& e) {
36378       {
36379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36380       };
36381     } catch (...) {
36382       {
36383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36384       };
36385     }
36386   }
36387 }
36388
36389
36390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
36391   void * jresult ;
36392   Dali::PinchGestureDetector *arg1 = 0 ;
36393   Dali::PinchGestureDetector *result = 0 ;
36394
36395   arg1 = (Dali::PinchGestureDetector *)jarg1;
36396   if (!arg1) {
36397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36398     return 0;
36399   }
36400   {
36401     try {
36402       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
36403     } catch (std::out_of_range& e) {
36404       {
36405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36406       };
36407     } catch (std::exception& e) {
36408       {
36409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36410       };
36411     } catch (...) {
36412       {
36413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36414       };
36415     }
36416   }
36417   jresult = (void *)result;
36418   return jresult;
36419 }
36420
36421
36422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
36423   void * jresult ;
36424   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36425   Dali::PinchGestureDetector *arg2 = 0 ;
36426   Dali::PinchGestureDetector *result = 0 ;
36427
36428   arg1 = (Dali::PinchGestureDetector *)jarg1;
36429   arg2 = (Dali::PinchGestureDetector *)jarg2;
36430   if (!arg2) {
36431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36432     return 0;
36433   }
36434   {
36435     try {
36436       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
36437     } catch (std::out_of_range& e) {
36438       {
36439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36440       };
36441     } catch (std::exception& e) {
36442       {
36443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36444       };
36445     } catch (...) {
36446       {
36447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36448       };
36449     }
36450   }
36451   jresult = (void *)result;
36452   return jresult;
36453 }
36454
36455
36456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
36457   void * jresult ;
36458   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36459   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
36460
36461   arg1 = (Dali::PinchGestureDetector *)jarg1;
36462   {
36463     try {
36464       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36465     } catch (std::out_of_range& e) {
36466       {
36467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36468       };
36469     } catch (std::exception& e) {
36470       {
36471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36472       };
36473     } catch (...) {
36474       {
36475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36476       };
36477     }
36478   }
36479   jresult = (void *)result;
36480   return jresult;
36481 }
36482
36483
36484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
36485   void * jresult ;
36486   Dali::Gesture::State arg1 ;
36487   Dali::PinchGesture *result = 0 ;
36488
36489   arg1 = (Dali::Gesture::State)jarg1;
36490   {
36491     try {
36492       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
36493     } catch (std::out_of_range& e) {
36494       {
36495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36496       };
36497     } catch (std::exception& e) {
36498       {
36499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36500       };
36501     } catch (...) {
36502       {
36503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36504       };
36505     }
36506   }
36507   jresult = (void *)result;
36508   return jresult;
36509 }
36510
36511
36512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
36513   void * jresult ;
36514   Dali::PinchGesture *arg1 = 0 ;
36515   Dali::PinchGesture *result = 0 ;
36516
36517   arg1 = (Dali::PinchGesture *)jarg1;
36518   if (!arg1) {
36519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36520     return 0;
36521   }
36522   {
36523     try {
36524       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
36525     } catch (std::out_of_range& e) {
36526       {
36527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36528       };
36529     } catch (std::exception& e) {
36530       {
36531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36532       };
36533     } catch (...) {
36534       {
36535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36536       };
36537     }
36538   }
36539   jresult = (void *)result;
36540   return jresult;
36541 }
36542
36543
36544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
36545   void * jresult ;
36546   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36547   Dali::PinchGesture *arg2 = 0 ;
36548   Dali::PinchGesture *result = 0 ;
36549
36550   arg1 = (Dali::PinchGesture *)jarg1;
36551   arg2 = (Dali::PinchGesture *)jarg2;
36552   if (!arg2) {
36553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36554     return 0;
36555   }
36556   {
36557     try {
36558       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
36559     } catch (std::out_of_range& e) {
36560       {
36561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36562       };
36563     } catch (std::exception& e) {
36564       {
36565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36566       };
36567     } catch (...) {
36568       {
36569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36570       };
36571     }
36572   }
36573   jresult = (void *)result;
36574   return jresult;
36575 }
36576
36577
36578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
36579   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36580
36581   arg1 = (Dali::PinchGesture *)jarg1;
36582   {
36583     try {
36584       delete arg1;
36585     } catch (std::out_of_range& e) {
36586       {
36587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36588       };
36589     } catch (std::exception& e) {
36590       {
36591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36592       };
36593     } catch (...) {
36594       {
36595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36596       };
36597     }
36598   }
36599 }
36600
36601
36602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
36603   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36604   float arg2 ;
36605
36606   arg1 = (Dali::PinchGesture *)jarg1;
36607   arg2 = (float)jarg2;
36608   if (arg1) (arg1)->scale = arg2;
36609 }
36610
36611
36612 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
36613   float jresult ;
36614   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36615   float result;
36616
36617   arg1 = (Dali::PinchGesture *)jarg1;
36618   result = (float) ((arg1)->scale);
36619   jresult = result;
36620   return jresult;
36621 }
36622
36623
36624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
36625   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36626   float arg2 ;
36627
36628   arg1 = (Dali::PinchGesture *)jarg1;
36629   arg2 = (float)jarg2;
36630   if (arg1) (arg1)->speed = arg2;
36631 }
36632
36633
36634 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
36635   float jresult ;
36636   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36637   float result;
36638
36639   arg1 = (Dali::PinchGesture *)jarg1;
36640   result = (float) ((arg1)->speed);
36641   jresult = result;
36642   return jresult;
36643 }
36644
36645
36646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
36647   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36648   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36649
36650   arg1 = (Dali::PinchGesture *)jarg1;
36651   arg2 = (Dali::Vector2 *)jarg2;
36652   if (arg1) (arg1)->screenCenterPoint = *arg2;
36653 }
36654
36655
36656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
36657   void * jresult ;
36658   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36659   Dali::Vector2 *result = 0 ;
36660
36661   arg1 = (Dali::PinchGesture *)jarg1;
36662   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
36663   jresult = (void *)result;
36664   return jresult;
36665 }
36666
36667
36668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
36669   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36670   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36671
36672   arg1 = (Dali::PinchGesture *)jarg1;
36673   arg2 = (Dali::Vector2 *)jarg2;
36674   if (arg1) (arg1)->localCenterPoint = *arg2;
36675 }
36676
36677
36678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
36679   void * jresult ;
36680   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36681   Dali::Vector2 *result = 0 ;
36682
36683   arg1 = (Dali::PinchGesture *)jarg1;
36684   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
36685   jresult = (void *)result;
36686   return jresult;
36687 }
36688
36689
36690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
36691   void * jresult ;
36692   Dali::TapGestureDetector *result = 0 ;
36693
36694   {
36695     try {
36696       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
36697     } catch (std::out_of_range& e) {
36698       {
36699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36700       };
36701     } catch (std::exception& e) {
36702       {
36703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36704       };
36705     } catch (...) {
36706       {
36707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36708       };
36709     }
36710   }
36711   jresult = (void *)result;
36712   return jresult;
36713 }
36714
36715
36716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
36717   void * jresult ;
36718   Dali::TapGestureDetector result;
36719
36720   {
36721     try {
36722       result = Dali::TapGestureDetector::New();
36723     } catch (std::out_of_range& e) {
36724       {
36725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36726       };
36727     } catch (std::exception& e) {
36728       {
36729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36730       };
36731     } catch (...) {
36732       {
36733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36734       };
36735     }
36736   }
36737   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36738   return jresult;
36739 }
36740
36741
36742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
36743   void * jresult ;
36744   unsigned int arg1 ;
36745   Dali::TapGestureDetector result;
36746
36747   arg1 = (unsigned int)jarg1;
36748   {
36749     try {
36750       result = Dali::TapGestureDetector::New(arg1);
36751     } catch (std::out_of_range& e) {
36752       {
36753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36754       };
36755     } catch (std::exception& e) {
36756       {
36757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36758       };
36759     } catch (...) {
36760       {
36761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36762       };
36763     }
36764   }
36765   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36766   return jresult;
36767 }
36768
36769
36770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
36771   void * jresult ;
36772   Dali::BaseHandle arg1 ;
36773   Dali::BaseHandle *argp1 ;
36774   Dali::TapGestureDetector result;
36775
36776   argp1 = (Dali::BaseHandle *)jarg1;
36777   if (!argp1) {
36778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36779     return 0;
36780   }
36781   arg1 = *argp1;
36782   {
36783     try {
36784       result = Dali::TapGestureDetector::DownCast(arg1);
36785     } catch (std::out_of_range& e) {
36786       {
36787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36788       };
36789     } catch (std::exception& e) {
36790       {
36791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36792       };
36793     } catch (...) {
36794       {
36795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36796       };
36797     }
36798   }
36799   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36800   return jresult;
36801 }
36802
36803
36804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
36805   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36806
36807   arg1 = (Dali::TapGestureDetector *)jarg1;
36808   {
36809     try {
36810       delete arg1;
36811     } catch (std::out_of_range& e) {
36812       {
36813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36814       };
36815     } catch (std::exception& e) {
36816       {
36817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36818       };
36819     } catch (...) {
36820       {
36821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36822       };
36823     }
36824   }
36825 }
36826
36827
36828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
36829   void * jresult ;
36830   Dali::TapGestureDetector *arg1 = 0 ;
36831   Dali::TapGestureDetector *result = 0 ;
36832
36833   arg1 = (Dali::TapGestureDetector *)jarg1;
36834   if (!arg1) {
36835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36836     return 0;
36837   }
36838   {
36839     try {
36840       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
36841     } catch (std::out_of_range& e) {
36842       {
36843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36844       };
36845     } catch (std::exception& e) {
36846       {
36847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36848       };
36849     } catch (...) {
36850       {
36851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36852       };
36853     }
36854   }
36855   jresult = (void *)result;
36856   return jresult;
36857 }
36858
36859
36860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
36861   void * jresult ;
36862   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36863   Dali::TapGestureDetector *arg2 = 0 ;
36864   Dali::TapGestureDetector *result = 0 ;
36865
36866   arg1 = (Dali::TapGestureDetector *)jarg1;
36867   arg2 = (Dali::TapGestureDetector *)jarg2;
36868   if (!arg2) {
36869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36870     return 0;
36871   }
36872   {
36873     try {
36874       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
36875     } catch (std::out_of_range& e) {
36876       {
36877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36878       };
36879     } catch (std::exception& e) {
36880       {
36881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36882       };
36883     } catch (...) {
36884       {
36885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36886       };
36887     }
36888   }
36889   jresult = (void *)result;
36890   return jresult;
36891 }
36892
36893
36894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
36895   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36896   unsigned int arg2 ;
36897
36898   arg1 = (Dali::TapGestureDetector *)jarg1;
36899   arg2 = (unsigned int)jarg2;
36900   {
36901     try {
36902       (arg1)->SetMinimumTapsRequired(arg2);
36903     } catch (std::out_of_range& e) {
36904       {
36905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36906       };
36907     } catch (std::exception& e) {
36908       {
36909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36910       };
36911     } catch (...) {
36912       {
36913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36914       };
36915     }
36916   }
36917 }
36918
36919
36920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
36921   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36922   unsigned int arg2 ;
36923
36924   arg1 = (Dali::TapGestureDetector *)jarg1;
36925   arg2 = (unsigned int)jarg2;
36926   {
36927     try {
36928       (arg1)->SetMaximumTapsRequired(arg2);
36929     } catch (std::out_of_range& e) {
36930       {
36931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36932       };
36933     } catch (std::exception& e) {
36934       {
36935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36936       };
36937     } catch (...) {
36938       {
36939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36940       };
36941     }
36942   }
36943 }
36944
36945
36946 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
36947   unsigned int jresult ;
36948   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36949   unsigned int result;
36950
36951   arg1 = (Dali::TapGestureDetector *)jarg1;
36952   {
36953     try {
36954       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
36955     } catch (std::out_of_range& e) {
36956       {
36957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36958       };
36959     } catch (std::exception& e) {
36960       {
36961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36962       };
36963     } catch (...) {
36964       {
36965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36966       };
36967     }
36968   }
36969   jresult = result;
36970   return jresult;
36971 }
36972
36973
36974 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
36975   unsigned int jresult ;
36976   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36977   unsigned int result;
36978
36979   arg1 = (Dali::TapGestureDetector *)jarg1;
36980   {
36981     try {
36982       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
36983     } catch (std::out_of_range& e) {
36984       {
36985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36986       };
36987     } catch (std::exception& e) {
36988       {
36989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36990       };
36991     } catch (...) {
36992       {
36993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36994       };
36995     }
36996   }
36997   jresult = result;
36998   return jresult;
36999 }
37000
37001
37002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
37003   void * jresult ;
37004   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37005   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
37006
37007   arg1 = (Dali::TapGestureDetector *)jarg1;
37008   {
37009     try {
37010       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
37011     } catch (std::out_of_range& e) {
37012       {
37013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37014       };
37015     } catch (std::exception& e) {
37016       {
37017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37018       };
37019     } catch (...) {
37020       {
37021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37022       };
37023     }
37024   }
37025   jresult = (void *)result;
37026   return jresult;
37027 }
37028
37029
37030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
37031   void * jresult ;
37032   Dali::TapGesture *result = 0 ;
37033
37034   {
37035     try {
37036       result = (Dali::TapGesture *)new Dali::TapGesture();
37037     } catch (std::out_of_range& e) {
37038       {
37039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37040       };
37041     } catch (std::exception& e) {
37042       {
37043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37044       };
37045     } catch (...) {
37046       {
37047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37048       };
37049     }
37050   }
37051   jresult = (void *)result;
37052   return jresult;
37053 }
37054
37055
37056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
37057   void * jresult ;
37058   Dali::TapGesture *arg1 = 0 ;
37059   Dali::TapGesture *result = 0 ;
37060
37061   arg1 = (Dali::TapGesture *)jarg1;
37062   if (!arg1) {
37063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37064     return 0;
37065   }
37066   {
37067     try {
37068       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
37069     } catch (std::out_of_range& e) {
37070       {
37071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37072       };
37073     } catch (std::exception& e) {
37074       {
37075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37076       };
37077     } catch (...) {
37078       {
37079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37080       };
37081     }
37082   }
37083   jresult = (void *)result;
37084   return jresult;
37085 }
37086
37087
37088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
37089   void * jresult ;
37090   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37091   Dali::TapGesture *arg2 = 0 ;
37092   Dali::TapGesture *result = 0 ;
37093
37094   arg1 = (Dali::TapGesture *)jarg1;
37095   arg2 = (Dali::TapGesture *)jarg2;
37096   if (!arg2) {
37097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37098     return 0;
37099   }
37100   {
37101     try {
37102       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
37103     } catch (std::out_of_range& e) {
37104       {
37105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37106       };
37107     } catch (std::exception& e) {
37108       {
37109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37110       };
37111     } catch (...) {
37112       {
37113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37114       };
37115     }
37116   }
37117   jresult = (void *)result;
37118   return jresult;
37119 }
37120
37121
37122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
37123   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37124
37125   arg1 = (Dali::TapGesture *)jarg1;
37126   {
37127     try {
37128       delete arg1;
37129     } catch (std::out_of_range& e) {
37130       {
37131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37132       };
37133     } catch (std::exception& e) {
37134       {
37135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37136       };
37137     } catch (...) {
37138       {
37139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37140       };
37141     }
37142   }
37143 }
37144
37145
37146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
37147   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37148   unsigned int arg2 ;
37149
37150   arg1 = (Dali::TapGesture *)jarg1;
37151   arg2 = (unsigned int)jarg2;
37152   if (arg1) (arg1)->numberOfTaps = arg2;
37153 }
37154
37155
37156 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
37157   unsigned int jresult ;
37158   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37159   unsigned int result;
37160
37161   arg1 = (Dali::TapGesture *)jarg1;
37162   result = (unsigned int) ((arg1)->numberOfTaps);
37163   jresult = result;
37164   return jresult;
37165 }
37166
37167
37168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
37169   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37170   unsigned int arg2 ;
37171
37172   arg1 = (Dali::TapGesture *)jarg1;
37173   arg2 = (unsigned int)jarg2;
37174   if (arg1) (arg1)->numberOfTouches = arg2;
37175 }
37176
37177
37178 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
37179   unsigned int jresult ;
37180   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37181   unsigned int result;
37182
37183   arg1 = (Dali::TapGesture *)jarg1;
37184   result = (unsigned int) ((arg1)->numberOfTouches);
37185   jresult = result;
37186   return jresult;
37187 }
37188
37189
37190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
37191   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37192   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37193
37194   arg1 = (Dali::TapGesture *)jarg1;
37195   arg2 = (Dali::Vector2 *)jarg2;
37196   if (arg1) (arg1)->screenPoint = *arg2;
37197 }
37198
37199
37200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
37201   void * jresult ;
37202   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37203   Dali::Vector2 *result = 0 ;
37204
37205   arg1 = (Dali::TapGesture *)jarg1;
37206   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
37207   jresult = (void *)result;
37208   return jresult;
37209 }
37210
37211
37212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
37213   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37214   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37215
37216   arg1 = (Dali::TapGesture *)jarg1;
37217   arg2 = (Dali::Vector2 *)jarg2;
37218   if (arg1) (arg1)->localPoint = *arg2;
37219 }
37220
37221
37222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
37223   void * jresult ;
37224   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37225   Dali::Vector2 *result = 0 ;
37226
37227   arg1 = (Dali::TapGesture *)jarg1;
37228   result = (Dali::Vector2 *)& ((arg1)->localPoint);
37229   jresult = (void *)result;
37230   return jresult;
37231 }
37232
37233
37234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
37235   void * jresult ;
37236   Dali::AlphaFunction *result = 0 ;
37237
37238   {
37239     try {
37240       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
37241     } catch (std::out_of_range& e) {
37242       {
37243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37244       };
37245     } catch (std::exception& e) {
37246       {
37247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37248       };
37249     } catch (...) {
37250       {
37251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37252       };
37253     }
37254   }
37255   jresult = (void *)result;
37256   return jresult;
37257 }
37258
37259
37260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
37261   void * jresult ;
37262   Dali::AlphaFunction::BuiltinFunction arg1 ;
37263   Dali::AlphaFunction *result = 0 ;
37264
37265   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
37266   {
37267     try {
37268       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37269     } catch (std::out_of_range& e) {
37270       {
37271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37272       };
37273     } catch (std::exception& e) {
37274       {
37275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37276       };
37277     } catch (...) {
37278       {
37279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37280       };
37281     }
37282   }
37283   jresult = (void *)result;
37284   return jresult;
37285 }
37286
37287
37288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
37289   void * jresult ;
37290   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
37291   Dali::AlphaFunction *result = 0 ;
37292
37293   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
37294   {
37295     try {
37296       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37297     } catch (std::out_of_range& e) {
37298       {
37299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37300       };
37301     } catch (std::exception& e) {
37302       {
37303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37304       };
37305     } catch (...) {
37306       {
37307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37308       };
37309     }
37310   }
37311   jresult = (void *)result;
37312   return jresult;
37313 }
37314
37315
37316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
37317   void * jresult ;
37318   Dali::Vector2 *arg1 = 0 ;
37319   Dali::Vector2 *arg2 = 0 ;
37320   Dali::AlphaFunction *result = 0 ;
37321
37322   arg1 = (Dali::Vector2 *)jarg1;
37323   if (!arg1) {
37324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37325     return 0;
37326   }
37327   arg2 = (Dali::Vector2 *)jarg2;
37328   if (!arg2) {
37329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37330     return 0;
37331   }
37332   {
37333     try {
37334       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
37335     } catch (std::out_of_range& e) {
37336       {
37337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37338       };
37339     } catch (std::exception& e) {
37340       {
37341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37342       };
37343     } catch (...) {
37344       {
37345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37346       };
37347     }
37348   }
37349   jresult = (void *)result;
37350   return jresult;
37351 }
37352
37353
37354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
37355   void * jresult ;
37356   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37357   Dali::Vector4 result;
37358
37359   arg1 = (Dali::AlphaFunction *)jarg1;
37360   {
37361     try {
37362       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
37363     } catch (std::out_of_range& e) {
37364       {
37365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37366       };
37367     } catch (std::exception& e) {
37368       {
37369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37370       };
37371     } catch (...) {
37372       {
37373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37374       };
37375     }
37376   }
37377   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
37378   return jresult;
37379 }
37380
37381
37382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
37383   void * jresult ;
37384   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37385   Dali::AlphaFunctionPrototype result;
37386
37387   arg1 = (Dali::AlphaFunction *)jarg1;
37388   {
37389     try {
37390       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
37391     } catch (std::out_of_range& e) {
37392       {
37393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37394       };
37395     } catch (std::exception& e) {
37396       {
37397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37398       };
37399     } catch (...) {
37400       {
37401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37402       };
37403     }
37404   }
37405   jresult = (void *)result;
37406   return jresult;
37407 }
37408
37409
37410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
37411   int jresult ;
37412   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37413   Dali::AlphaFunction::BuiltinFunction result;
37414
37415   arg1 = (Dali::AlphaFunction *)jarg1;
37416   {
37417     try {
37418       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
37419     } catch (std::out_of_range& e) {
37420       {
37421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37422       };
37423     } catch (std::exception& e) {
37424       {
37425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37426       };
37427     } catch (...) {
37428       {
37429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37430       };
37431     }
37432   }
37433   jresult = (int)result;
37434   return jresult;
37435 }
37436
37437
37438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
37439   int jresult ;
37440   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37441   Dali::AlphaFunction::Mode result;
37442
37443   arg1 = (Dali::AlphaFunction *)jarg1;
37444   {
37445     try {
37446       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
37447     } catch (std::out_of_range& e) {
37448       {
37449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37450       };
37451     } catch (std::exception& e) {
37452       {
37453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37454       };
37455     } catch (...) {
37456       {
37457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37458       };
37459     }
37460   }
37461   jresult = (int)result;
37462   return jresult;
37463 }
37464
37465
37466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
37467   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37468
37469   arg1 = (Dali::AlphaFunction *)jarg1;
37470   {
37471     try {
37472       delete arg1;
37473     } catch (std::out_of_range& e) {
37474       {
37475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37476       };
37477     } catch (std::exception& e) {
37478       {
37479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37480       };
37481     } catch (...) {
37482       {
37483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37484       };
37485     }
37486   }
37487 }
37488
37489
37490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
37491   void * jresult ;
37492   Dali::KeyFrames result;
37493
37494   {
37495     try {
37496       result = Dali::KeyFrames::New();
37497     } catch (std::out_of_range& e) {
37498       {
37499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37500       };
37501     } catch (std::exception& e) {
37502       {
37503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37504       };
37505     } catch (...) {
37506       {
37507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37508       };
37509     }
37510   }
37511   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37512   return jresult;
37513 }
37514
37515
37516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
37517   void * jresult ;
37518   Dali::BaseHandle arg1 ;
37519   Dali::BaseHandle *argp1 ;
37520   Dali::KeyFrames result;
37521
37522   argp1 = (Dali::BaseHandle *)jarg1;
37523   if (!argp1) {
37524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37525     return 0;
37526   }
37527   arg1 = *argp1;
37528   {
37529     try {
37530       result = Dali::KeyFrames::DownCast(arg1);
37531     } catch (std::out_of_range& e) {
37532       {
37533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37534       };
37535     } catch (std::exception& e) {
37536       {
37537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37538       };
37539     } catch (...) {
37540       {
37541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37542       };
37543     }
37544   }
37545   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37546   return jresult;
37547 }
37548
37549
37550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
37551   void * jresult ;
37552   Dali::KeyFrames *result = 0 ;
37553
37554   {
37555     try {
37556       result = (Dali::KeyFrames *)new Dali::KeyFrames();
37557     } catch (std::out_of_range& e) {
37558       {
37559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37560       };
37561     } catch (std::exception& e) {
37562       {
37563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37564       };
37565     } catch (...) {
37566       {
37567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37568       };
37569     }
37570   }
37571   jresult = (void *)result;
37572   return jresult;
37573 }
37574
37575
37576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
37577   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37578
37579   arg1 = (Dali::KeyFrames *)jarg1;
37580   {
37581     try {
37582       delete arg1;
37583     } catch (std::out_of_range& e) {
37584       {
37585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37586       };
37587     } catch (std::exception& e) {
37588       {
37589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37590       };
37591     } catch (...) {
37592       {
37593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37594       };
37595     }
37596   }
37597 }
37598
37599
37600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
37601   void * jresult ;
37602   Dali::KeyFrames *arg1 = 0 ;
37603   Dali::KeyFrames *result = 0 ;
37604
37605   arg1 = (Dali::KeyFrames *)jarg1;
37606   if (!arg1) {
37607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37608     return 0;
37609   }
37610   {
37611     try {
37612       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
37613     } catch (std::out_of_range& e) {
37614       {
37615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37616       };
37617     } catch (std::exception& e) {
37618       {
37619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37620       };
37621     } catch (...) {
37622       {
37623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37624       };
37625     }
37626   }
37627   jresult = (void *)result;
37628   return jresult;
37629 }
37630
37631
37632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
37633   void * jresult ;
37634   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37635   Dali::KeyFrames *arg2 = 0 ;
37636   Dali::KeyFrames *result = 0 ;
37637
37638   arg1 = (Dali::KeyFrames *)jarg1;
37639   arg2 = (Dali::KeyFrames *)jarg2;
37640   if (!arg2) {
37641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37642     return 0;
37643   }
37644   {
37645     try {
37646       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
37647     } catch (std::out_of_range& e) {
37648       {
37649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37650       };
37651     } catch (std::exception& e) {
37652       {
37653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37654       };
37655     } catch (...) {
37656       {
37657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37658       };
37659     }
37660   }
37661   jresult = (void *)result;
37662   return jresult;
37663 }
37664
37665
37666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
37667   int jresult ;
37668   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37669   Dali::Property::Type result;
37670
37671   arg1 = (Dali::KeyFrames *)jarg1;
37672   {
37673     try {
37674       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
37675     } catch (std::out_of_range& e) {
37676       {
37677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37678       };
37679     } catch (std::exception& e) {
37680       {
37681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37682       };
37683     } catch (...) {
37684       {
37685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37686       };
37687     }
37688   }
37689   jresult = (int)result;
37690   return jresult;
37691 }
37692
37693
37694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
37695   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37696   float arg2 ;
37697   Dali::Property::Value arg3 ;
37698   Dali::Property::Value *argp3 ;
37699
37700   arg1 = (Dali::KeyFrames *)jarg1;
37701   arg2 = (float)jarg2;
37702   argp3 = (Dali::Property::Value *)jarg3;
37703   if (!argp3) {
37704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37705     return ;
37706   }
37707   arg3 = *argp3;
37708   {
37709     try {
37710       (arg1)->Add(arg2,arg3);
37711     } catch (std::out_of_range& e) {
37712       {
37713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37714       };
37715     } catch (std::exception& e) {
37716       {
37717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37718       };
37719     } catch (...) {
37720       {
37721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37722       };
37723     }
37724   }
37725 }
37726
37727
37728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
37729   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37730   float arg2 ;
37731   Dali::Property::Value arg3 ;
37732   Dali::AlphaFunction arg4 ;
37733   Dali::Property::Value *argp3 ;
37734   Dali::AlphaFunction *argp4 ;
37735
37736   arg1 = (Dali::KeyFrames *)jarg1;
37737   arg2 = (float)jarg2;
37738   argp3 = (Dali::Property::Value *)jarg3;
37739   if (!argp3) {
37740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37741     return ;
37742   }
37743   arg3 = *argp3;
37744   argp4 = (Dali::AlphaFunction *)jarg4;
37745   if (!argp4) {
37746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
37747     return ;
37748   }
37749   arg4 = *argp4;
37750   {
37751     try {
37752       (arg1)->Add(arg2,arg3,arg4);
37753     } catch (std::out_of_range& e) {
37754       {
37755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37756       };
37757     } catch (std::exception& e) {
37758       {
37759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37760       };
37761     } catch (...) {
37762       {
37763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37764       };
37765     }
37766   }
37767 }
37768
37769
37770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
37771   int jresult ;
37772   int result;
37773
37774   result = (int)Dali::Path::Property::POINTS;
37775   jresult = (int)result;
37776   return jresult;
37777 }
37778
37779
37780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
37781   int jresult ;
37782   int result;
37783
37784   result = (int)Dali::Path::Property::CONTROL_POINTS;
37785   jresult = (int)result;
37786   return jresult;
37787 }
37788
37789
37790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
37791   void * jresult ;
37792   Dali::Path::Property *result = 0 ;
37793
37794   {
37795     try {
37796       result = (Dali::Path::Property *)new Dali::Path::Property();
37797     } catch (std::out_of_range& e) {
37798       {
37799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37800       };
37801     } catch (std::exception& e) {
37802       {
37803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37804       };
37805     } catch (...) {
37806       {
37807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37808       };
37809     }
37810   }
37811   jresult = (void *)result;
37812   return jresult;
37813 }
37814
37815
37816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
37817   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
37818
37819   arg1 = (Dali::Path::Property *)jarg1;
37820   {
37821     try {
37822       delete arg1;
37823     } catch (std::out_of_range& e) {
37824       {
37825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37826       };
37827     } catch (std::exception& e) {
37828       {
37829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37830       };
37831     } catch (...) {
37832       {
37833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37834       };
37835     }
37836   }
37837 }
37838
37839
37840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
37841   void * jresult ;
37842   Dali::Path result;
37843
37844   {
37845     try {
37846       result = Dali::Path::New();
37847     } catch (std::out_of_range& e) {
37848       {
37849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37850       };
37851     } catch (std::exception& e) {
37852       {
37853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37854       };
37855     } catch (...) {
37856       {
37857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37858       };
37859     }
37860   }
37861   jresult = new Dali::Path((const Dali::Path &)result);
37862   return jresult;
37863 }
37864
37865
37866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
37867   void * jresult ;
37868   Dali::BaseHandle arg1 ;
37869   Dali::BaseHandle *argp1 ;
37870   Dali::Path result;
37871
37872   argp1 = (Dali::BaseHandle *)jarg1;
37873   if (!argp1) {
37874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37875     return 0;
37876   }
37877   arg1 = *argp1;
37878   {
37879     try {
37880       result = Dali::Path::DownCast(arg1);
37881     } catch (std::out_of_range& e) {
37882       {
37883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37884       };
37885     } catch (std::exception& e) {
37886       {
37887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37888       };
37889     } catch (...) {
37890       {
37891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37892       };
37893     }
37894   }
37895   jresult = new Dali::Path((const Dali::Path &)result);
37896   return jresult;
37897 }
37898
37899
37900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
37901   void * jresult ;
37902   Dali::Path *result = 0 ;
37903
37904   {
37905     try {
37906       result = (Dali::Path *)new Dali::Path();
37907     } catch (std::out_of_range& e) {
37908       {
37909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37910       };
37911     } catch (std::exception& e) {
37912       {
37913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37914       };
37915     } catch (...) {
37916       {
37917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37918       };
37919     }
37920   }
37921   jresult = (void *)result;
37922   return jresult;
37923 }
37924
37925
37926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
37927   Dali::Path *arg1 = (Dali::Path *) 0 ;
37928
37929   arg1 = (Dali::Path *)jarg1;
37930   {
37931     try {
37932       delete arg1;
37933     } catch (std::out_of_range& e) {
37934       {
37935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37936       };
37937     } catch (std::exception& e) {
37938       {
37939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37940       };
37941     } catch (...) {
37942       {
37943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37944       };
37945     }
37946   }
37947 }
37948
37949
37950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
37951   void * jresult ;
37952   Dali::Path *arg1 = 0 ;
37953   Dali::Path *result = 0 ;
37954
37955   arg1 = (Dali::Path *)jarg1;
37956   if (!arg1) {
37957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
37958     return 0;
37959   }
37960   {
37961     try {
37962       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
37963     } catch (std::out_of_range& e) {
37964       {
37965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37966       };
37967     } catch (std::exception& e) {
37968       {
37969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37970       };
37971     } catch (...) {
37972       {
37973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37974       };
37975     }
37976   }
37977   jresult = (void *)result;
37978   return jresult;
37979 }
37980
37981
37982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
37983   void * jresult ;
37984   Dali::Path *arg1 = (Dali::Path *) 0 ;
37985   Dali::Path *arg2 = 0 ;
37986   Dali::Path *result = 0 ;
37987
37988   arg1 = (Dali::Path *)jarg1;
37989   arg2 = (Dali::Path *)jarg2;
37990   if (!arg2) {
37991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
37992     return 0;
37993   }
37994   {
37995     try {
37996       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
37997     } catch (std::out_of_range& e) {
37998       {
37999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38000       };
38001     } catch (std::exception& e) {
38002       {
38003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38004       };
38005     } catch (...) {
38006       {
38007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38008       };
38009     }
38010   }
38011   jresult = (void *)result;
38012   return jresult;
38013 }
38014
38015
38016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
38017   Dali::Path *arg1 = (Dali::Path *) 0 ;
38018   Dali::Vector3 *arg2 = 0 ;
38019
38020   arg1 = (Dali::Path *)jarg1;
38021   arg2 = (Dali::Vector3 *)jarg2;
38022   if (!arg2) {
38023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38024     return ;
38025   }
38026   {
38027     try {
38028       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
38029     } catch (std::out_of_range& e) {
38030       {
38031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38032       };
38033     } catch (std::exception& e) {
38034       {
38035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38036       };
38037     } catch (...) {
38038       {
38039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38040       };
38041     }
38042   }
38043 }
38044
38045
38046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
38047   Dali::Path *arg1 = (Dali::Path *) 0 ;
38048   Dali::Vector3 *arg2 = 0 ;
38049
38050   arg1 = (Dali::Path *)jarg1;
38051   arg2 = (Dali::Vector3 *)jarg2;
38052   if (!arg2) {
38053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38054     return ;
38055   }
38056   {
38057     try {
38058       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
38059     } catch (std::out_of_range& e) {
38060       {
38061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38062       };
38063     } catch (std::exception& e) {
38064       {
38065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38066       };
38067     } catch (...) {
38068       {
38069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38070       };
38071     }
38072   }
38073 }
38074
38075
38076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
38077   Dali::Path *arg1 = (Dali::Path *) 0 ;
38078   float arg2 ;
38079
38080   arg1 = (Dali::Path *)jarg1;
38081   arg2 = (float)jarg2;
38082   {
38083     try {
38084       (arg1)->GenerateControlPoints(arg2);
38085     } catch (std::out_of_range& e) {
38086       {
38087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38088       };
38089     } catch (std::exception& e) {
38090       {
38091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38092       };
38093     } catch (...) {
38094       {
38095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38096       };
38097     }
38098   }
38099 }
38100
38101
38102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
38103   Dali::Path *arg1 = (Dali::Path *) 0 ;
38104   float arg2 ;
38105   Dali::Vector3 *arg3 = 0 ;
38106   Dali::Vector3 *arg4 = 0 ;
38107
38108   arg1 = (Dali::Path *)jarg1;
38109   arg2 = (float)jarg2;
38110   arg3 = (Dali::Vector3 *)jarg3;
38111   if (!arg3) {
38112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38113     return ;
38114   }
38115   arg4 = (Dali::Vector3 *)jarg4;
38116   if (!arg4) {
38117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38118     return ;
38119   }
38120   {
38121     try {
38122       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
38123     } catch (std::out_of_range& e) {
38124       {
38125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38126       };
38127     } catch (std::exception& e) {
38128       {
38129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38130       };
38131     } catch (...) {
38132       {
38133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38134       };
38135     }
38136   }
38137 }
38138
38139
38140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
38141   void * jresult ;
38142   Dali::Path *arg1 = (Dali::Path *) 0 ;
38143   size_t arg2 ;
38144   Dali::Vector3 *result = 0 ;
38145
38146   arg1 = (Dali::Path *)jarg1;
38147   arg2 = (size_t)jarg2;
38148   {
38149     try {
38150       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
38151     } catch (std::out_of_range& e) {
38152       {
38153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38154       };
38155     } catch (std::exception& e) {
38156       {
38157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38158       };
38159     } catch (...) {
38160       {
38161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38162       };
38163     }
38164   }
38165   jresult = (void *)result;
38166   return jresult;
38167 }
38168
38169
38170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
38171   void * jresult ;
38172   Dali::Path *arg1 = (Dali::Path *) 0 ;
38173   size_t arg2 ;
38174   Dali::Vector3 *result = 0 ;
38175
38176   arg1 = (Dali::Path *)jarg1;
38177   arg2 = (size_t)jarg2;
38178   {
38179     try {
38180       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
38181     } catch (std::out_of_range& e) {
38182       {
38183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38184       };
38185     } catch (std::exception& e) {
38186       {
38187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38188       };
38189     } catch (...) {
38190       {
38191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38192       };
38193     }
38194   }
38195   jresult = (void *)result;
38196   return jresult;
38197 }
38198
38199
38200 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
38201   unsigned long jresult ;
38202   Dali::Path *arg1 = (Dali::Path *) 0 ;
38203   size_t result;
38204
38205   arg1 = (Dali::Path *)jarg1;
38206   {
38207     try {
38208       result = ((Dali::Path const *)arg1)->GetPointCount();
38209     } catch (std::out_of_range& e) {
38210       {
38211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38212       };
38213     } catch (std::exception& e) {
38214       {
38215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38216       };
38217     } catch (...) {
38218       {
38219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38220       };
38221     }
38222   }
38223   jresult = (unsigned long)result;
38224   return jresult;
38225 }
38226
38227
38228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
38229   void * jresult ;
38230   float arg1 ;
38231   Dali::TimePeriod *result = 0 ;
38232
38233   arg1 = (float)jarg1;
38234   {
38235     try {
38236       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
38237     } catch (std::out_of_range& e) {
38238       {
38239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38240       };
38241     } catch (std::exception& e) {
38242       {
38243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38244       };
38245     } catch (...) {
38246       {
38247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38248       };
38249     }
38250   }
38251   jresult = (void *)result;
38252   return jresult;
38253 }
38254
38255
38256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
38257   void * jresult ;
38258   float arg1 ;
38259   float arg2 ;
38260   Dali::TimePeriod *result = 0 ;
38261
38262   arg1 = (float)jarg1;
38263   arg2 = (float)jarg2;
38264   {
38265     try {
38266       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
38267     } catch (std::out_of_range& e) {
38268       {
38269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38270       };
38271     } catch (std::exception& e) {
38272       {
38273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38274       };
38275     } catch (...) {
38276       {
38277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38278       };
38279     }
38280   }
38281   jresult = (void *)result;
38282   return jresult;
38283 }
38284
38285
38286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
38287   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38288
38289   arg1 = (Dali::TimePeriod *)jarg1;
38290   {
38291     try {
38292       delete arg1;
38293     } catch (std::out_of_range& e) {
38294       {
38295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38296       };
38297     } catch (std::exception& e) {
38298       {
38299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38300       };
38301     } catch (...) {
38302       {
38303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38304       };
38305     }
38306   }
38307 }
38308
38309
38310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
38311   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38312   float arg2 ;
38313
38314   arg1 = (Dali::TimePeriod *)jarg1;
38315   arg2 = (float)jarg2;
38316   if (arg1) (arg1)->delaySeconds = arg2;
38317 }
38318
38319
38320 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
38321   float jresult ;
38322   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38323   float result;
38324
38325   arg1 = (Dali::TimePeriod *)jarg1;
38326   result = (float) ((arg1)->delaySeconds);
38327   jresult = result;
38328   return jresult;
38329 }
38330
38331
38332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
38333   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38334   float arg2 ;
38335
38336   arg1 = (Dali::TimePeriod *)jarg1;
38337   arg2 = (float)jarg2;
38338   if (arg1) (arg1)->durationSeconds = arg2;
38339 }
38340
38341
38342 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
38343   float jresult ;
38344   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38345   float result;
38346
38347   arg1 = (Dali::TimePeriod *)jarg1;
38348   result = (float) ((arg1)->durationSeconds);
38349   jresult = result;
38350   return jresult;
38351 }
38352
38353
38354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_0() {
38355   void * jresult ;
38356   Dali::Animation *result = 0 ;
38357
38358   {
38359     try {
38360       result = (Dali::Animation *)new Dali::Animation();
38361     } catch (std::out_of_range& e) {
38362       {
38363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38364       };
38365     } catch (std::exception& e) {
38366       {
38367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38368       };
38369     } catch (...) {
38370       {
38371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38372       };
38373     }
38374   }
38375   jresult = (void *)result;
38376   return jresult;
38377 }
38378
38379
38380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_New(float jarg1) {
38381   void * jresult ;
38382   float arg1 ;
38383   Dali::Animation result;
38384
38385   arg1 = (float)jarg1;
38386   {
38387     try {
38388       result = Dali::Animation::New(arg1);
38389     } catch (std::out_of_range& e) {
38390       {
38391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38392       };
38393     } catch (std::exception& e) {
38394       {
38395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38396       };
38397     } catch (...) {
38398       {
38399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38400       };
38401     }
38402   }
38403   jresult = new Dali::Animation((const Dali::Animation &)result);
38404   return jresult;
38405 }
38406
38407
38408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_DownCast(void * jarg1) {
38409   void * jresult ;
38410   Dali::BaseHandle arg1 ;
38411   Dali::BaseHandle *argp1 ;
38412   Dali::Animation result;
38413
38414   argp1 = (Dali::BaseHandle *)jarg1;
38415   if (!argp1) {
38416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38417     return 0;
38418   }
38419   arg1 = *argp1;
38420   {
38421     try {
38422       result = Dali::Animation::DownCast(arg1);
38423     } catch (std::out_of_range& e) {
38424       {
38425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38426       };
38427     } catch (std::exception& e) {
38428       {
38429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38430       };
38431     } catch (...) {
38432       {
38433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38434       };
38435     }
38436   }
38437   jresult = new Dali::Animation((const Dali::Animation &)result);
38438   return jresult;
38439 }
38440
38441
38442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Animation(void * jarg1) {
38443   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38444
38445   arg1 = (Dali::Animation *)jarg1;
38446   {
38447     try {
38448       delete arg1;
38449     } catch (std::out_of_range& e) {
38450       {
38451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38452       };
38453     } catch (std::exception& e) {
38454       {
38455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38456       };
38457     } catch (...) {
38458       {
38459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38460       };
38461     }
38462   }
38463 }
38464
38465
38466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_1(void * jarg1) {
38467   void * jresult ;
38468   Dali::Animation *arg1 = 0 ;
38469   Dali::Animation *result = 0 ;
38470
38471   arg1 = (Dali::Animation *)jarg1;
38472   if (!arg1) {
38473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38474     return 0;
38475   }
38476   {
38477     try {
38478       result = (Dali::Animation *)new Dali::Animation((Dali::Animation const &)*arg1);
38479     } catch (std::out_of_range& e) {
38480       {
38481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38482       };
38483     } catch (std::exception& e) {
38484       {
38485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38486       };
38487     } catch (...) {
38488       {
38489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38490       };
38491     }
38492   }
38493   jresult = (void *)result;
38494   return jresult;
38495 }
38496
38497
38498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_Assign(void * jarg1, void * jarg2) {
38499   void * jresult ;
38500   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38501   Dali::Animation *arg2 = 0 ;
38502   Dali::Animation *result = 0 ;
38503
38504   arg1 = (Dali::Animation *)jarg1;
38505   arg2 = (Dali::Animation *)jarg2;
38506   if (!arg2) {
38507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38508     return 0;
38509   }
38510   {
38511     try {
38512       result = (Dali::Animation *) &(arg1)->operator =((Dali::Animation const &)*arg2);
38513     } catch (std::out_of_range& e) {
38514       {
38515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38516       };
38517     } catch (std::exception& e) {
38518       {
38519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38520       };
38521     } catch (...) {
38522       {
38523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38524       };
38525     }
38526   }
38527   jresult = (void *)result;
38528   return jresult;
38529 }
38530
38531
38532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDuration(void * jarg1, float jarg2) {
38533   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38534   float arg2 ;
38535
38536   arg1 = (Dali::Animation *)jarg1;
38537   arg2 = (float)jarg2;
38538   {
38539     try {
38540       (arg1)->SetDuration(arg2);
38541     } catch (std::out_of_range& e) {
38542       {
38543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38544       };
38545     } catch (std::exception& e) {
38546       {
38547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38548       };
38549     } catch (...) {
38550       {
38551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38552       };
38553     }
38554   }
38555 }
38556
38557
38558 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetDuration(void * jarg1) {
38559   float jresult ;
38560   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38561   float result;
38562
38563   arg1 = (Dali::Animation *)jarg1;
38564   {
38565     try {
38566       result = (float)((Dali::Animation const *)arg1)->GetDuration();
38567     } catch (std::out_of_range& e) {
38568       {
38569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38570       };
38571     } catch (std::exception& e) {
38572       {
38573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38574       };
38575     } catch (...) {
38576       {
38577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38578       };
38579     }
38580   }
38581   jresult = result;
38582   return jresult;
38583 }
38584
38585
38586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLooping(void * jarg1, unsigned int jarg2) {
38587   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38588   bool arg2 ;
38589
38590   arg1 = (Dali::Animation *)jarg1;
38591   arg2 = jarg2 ? true : false;
38592   {
38593     try {
38594       (arg1)->SetLooping(arg2);
38595     } catch (std::out_of_range& e) {
38596       {
38597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38598       };
38599     } catch (std::exception& e) {
38600       {
38601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38602       };
38603     } catch (...) {
38604       {
38605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38606       };
38607     }
38608   }
38609 }
38610
38611
38612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLoopCount(void * jarg1, int jarg2) {
38613   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38614   int arg2 ;
38615
38616   arg1 = (Dali::Animation *)jarg1;
38617   arg2 = (int)jarg2;
38618   {
38619     try {
38620       (arg1)->SetLoopCount(arg2);
38621     } catch (std::out_of_range& e) {
38622       {
38623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38624       };
38625     } catch (std::exception& e) {
38626       {
38627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38628       };
38629     } catch (...) {
38630       {
38631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38632       };
38633     }
38634   }
38635 }
38636
38637
38638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetLoopCount(void * jarg1) {
38639   int jresult ;
38640   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38641   int result;
38642
38643   arg1 = (Dali::Animation *)jarg1;
38644   {
38645     try {
38646       result = (int)(arg1)->GetLoopCount();
38647     } catch (std::out_of_range& e) {
38648       {
38649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38650       };
38651     } catch (std::exception& e) {
38652       {
38653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38654       };
38655     } catch (...) {
38656       {
38657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38658       };
38659     }
38660   }
38661   jresult = result;
38662   return jresult;
38663 }
38664
38665
38666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetCurrentLoop(void * jarg1) {
38667   int jresult ;
38668   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38669   int result;
38670
38671   arg1 = (Dali::Animation *)jarg1;
38672   {
38673     try {
38674       result = (int)(arg1)->GetCurrentLoop();
38675     } catch (std::out_of_range& e) {
38676       {
38677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38678       };
38679     } catch (std::exception& e) {
38680       {
38681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38682       };
38683     } catch (...) {
38684       {
38685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38686       };
38687     }
38688   }
38689   jresult = result;
38690   return jresult;
38691 }
38692
38693
38694 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Animation_IsLooping(void * jarg1) {
38695   unsigned int jresult ;
38696   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38697   bool result;
38698
38699   arg1 = (Dali::Animation *)jarg1;
38700   {
38701     try {
38702       result = (bool)((Dali::Animation const *)arg1)->IsLooping();
38703     } catch (std::out_of_range& e) {
38704       {
38705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38706       };
38707     } catch (std::exception& e) {
38708       {
38709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38710       };
38711     } catch (...) {
38712       {
38713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38714       };
38715     }
38716   }
38717   jresult = result;
38718   return jresult;
38719 }
38720
38721
38722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetEndAction(void * jarg1, int jarg2) {
38723   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38724   Dali::Animation::EndAction arg2 ;
38725
38726   arg1 = (Dali::Animation *)jarg1;
38727   arg2 = (Dali::Animation::EndAction)jarg2;
38728   {
38729     try {
38730       (arg1)->SetEndAction(arg2);
38731     } catch (std::out_of_range& e) {
38732       {
38733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38734       };
38735     } catch (std::exception& e) {
38736       {
38737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38738       };
38739     } catch (...) {
38740       {
38741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38742       };
38743     }
38744   }
38745 }
38746
38747
38748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetEndAction(void * jarg1) {
38749   int jresult ;
38750   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38751   Dali::Animation::EndAction result;
38752
38753   arg1 = (Dali::Animation *)jarg1;
38754   {
38755     try {
38756       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetEndAction();
38757     } catch (std::out_of_range& e) {
38758       {
38759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38760       };
38761     } catch (std::exception& e) {
38762       {
38763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38764       };
38765     } catch (...) {
38766       {
38767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38768       };
38769     }
38770   }
38771   jresult = (int)result;
38772   return jresult;
38773 }
38774
38775
38776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDisconnectAction(void * jarg1, int jarg2) {
38777   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38778   Dali::Animation::EndAction arg2 ;
38779
38780   arg1 = (Dali::Animation *)jarg1;
38781   arg2 = (Dali::Animation::EndAction)jarg2;
38782   {
38783     try {
38784       (arg1)->SetDisconnectAction(arg2);
38785     } catch (std::out_of_range& e) {
38786       {
38787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38788       };
38789     } catch (std::exception& e) {
38790       {
38791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38792       };
38793     } catch (...) {
38794       {
38795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38796       };
38797     }
38798   }
38799 }
38800
38801
38802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetDisconnectAction(void * jarg1) {
38803   int jresult ;
38804   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38805   Dali::Animation::EndAction result;
38806
38807   arg1 = (Dali::Animation *)jarg1;
38808   {
38809     try {
38810       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetDisconnectAction();
38811     } catch (std::out_of_range& e) {
38812       {
38813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38814       };
38815     } catch (std::exception& e) {
38816       {
38817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38818       };
38819     } catch (...) {
38820       {
38821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38822       };
38823     }
38824   }
38825   jresult = (int)result;
38826   return jresult;
38827 }
38828
38829
38830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDefaultAlphaFunction(void * jarg1, void * jarg2) {
38831   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38832   Dali::AlphaFunction arg2 ;
38833   Dali::AlphaFunction *argp2 ;
38834
38835   arg1 = (Dali::Animation *)jarg1;
38836   argp2 = (Dali::AlphaFunction *)jarg2;
38837   if (!argp2) {
38838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
38839     return ;
38840   }
38841   arg2 = *argp2;
38842   {
38843     try {
38844       (arg1)->SetDefaultAlphaFunction(arg2);
38845     } catch (std::out_of_range& e) {
38846       {
38847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38848       };
38849     } catch (std::exception& e) {
38850       {
38851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38852       };
38853     } catch (...) {
38854       {
38855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38856       };
38857     }
38858   }
38859 }
38860
38861
38862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetDefaultAlphaFunction(void * jarg1) {
38863   void * jresult ;
38864   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38865   Dali::AlphaFunction result;
38866
38867   arg1 = (Dali::Animation *)jarg1;
38868   {
38869     try {
38870       result = ((Dali::Animation const *)arg1)->GetDefaultAlphaFunction();
38871     } catch (std::out_of_range& e) {
38872       {
38873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38874       };
38875     } catch (std::exception& e) {
38876       {
38877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38878       };
38879     } catch (...) {
38880       {
38881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38882       };
38883     }
38884   }
38885   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
38886   return jresult;
38887 }
38888
38889
38890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetCurrentProgress(void * jarg1, float jarg2) {
38891   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38892   float arg2 ;
38893
38894   arg1 = (Dali::Animation *)jarg1;
38895   arg2 = (float)jarg2;
38896   {
38897     try {
38898       (arg1)->SetCurrentProgress(arg2);
38899     } catch (std::out_of_range& e) {
38900       {
38901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38902       };
38903     } catch (std::exception& e) {
38904       {
38905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38906       };
38907     } catch (...) {
38908       {
38909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38910       };
38911     }
38912   }
38913 }
38914
38915
38916 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetCurrentProgress(void * jarg1) {
38917   float jresult ;
38918   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38919   float result;
38920
38921   arg1 = (Dali::Animation *)jarg1;
38922   {
38923     try {
38924       result = (float)(arg1)->GetCurrentProgress();
38925     } catch (std::out_of_range& e) {
38926       {
38927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38928       };
38929     } catch (std::exception& e) {
38930       {
38931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38932       };
38933     } catch (...) {
38934       {
38935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38936       };
38937     }
38938   }
38939   jresult = result;
38940   return jresult;
38941 }
38942
38943
38944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetSpeedFactor(void * jarg1, float jarg2) {
38945   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38946   float arg2 ;
38947
38948   arg1 = (Dali::Animation *)jarg1;
38949   arg2 = (float)jarg2;
38950   {
38951     try {
38952       (arg1)->SetSpeedFactor(arg2);
38953     } catch (std::out_of_range& e) {
38954       {
38955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38956       };
38957     } catch (std::exception& e) {
38958       {
38959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38960       };
38961     } catch (...) {
38962       {
38963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38964       };
38965     }
38966   }
38967 }
38968
38969
38970 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetSpeedFactor(void * jarg1) {
38971   float jresult ;
38972   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38973   float result;
38974
38975   arg1 = (Dali::Animation *)jarg1;
38976   {
38977     try {
38978       result = (float)((Dali::Animation const *)arg1)->GetSpeedFactor();
38979     } catch (std::out_of_range& e) {
38980       {
38981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38982       };
38983     } catch (std::exception& e) {
38984       {
38985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38986       };
38987     } catch (...) {
38988       {
38989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38990       };
38991     }
38992   }
38993   jresult = result;
38994   return jresult;
38995 }
38996
38997
38998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetPlayRange(void * jarg1, void * jarg2) {
38999   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39000   Dali::Vector2 *arg2 = 0 ;
39001
39002   arg1 = (Dali::Animation *)jarg1;
39003   arg2 = (Dali::Vector2 *)jarg2;
39004   if (!arg2) {
39005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39006     return ;
39007   }
39008   {
39009     try {
39010       (arg1)->SetPlayRange((Dali::Vector2 const &)*arg2);
39011     } catch (std::out_of_range& e) {
39012       {
39013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39014       };
39015     } catch (std::exception& e) {
39016       {
39017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39018       };
39019     } catch (...) {
39020       {
39021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39022       };
39023     }
39024   }
39025 }
39026
39027
39028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetPlayRange(void * jarg1) {
39029   void * jresult ;
39030   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39031   Dali::Vector2 result;
39032
39033   arg1 = (Dali::Animation *)jarg1;
39034   {
39035     try {
39036       result = ((Dali::Animation const *)arg1)->GetPlayRange();
39037     } catch (std::out_of_range& e) {
39038       {
39039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39040       };
39041     } catch (std::exception& e) {
39042       {
39043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39044       };
39045     } catch (...) {
39046       {
39047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39048       };
39049     }
39050   }
39051   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
39052   return jresult;
39053 }
39054
39055
39056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Play(void * jarg1) {
39057   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39058
39059   arg1 = (Dali::Animation *)jarg1;
39060   {
39061     try {
39062       (arg1)->Play();
39063     } catch (std::out_of_range& e) {
39064       {
39065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39066       };
39067     } catch (std::exception& e) {
39068       {
39069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39070       };
39071     } catch (...) {
39072       {
39073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39074       };
39075     }
39076   }
39077 }
39078
39079
39080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_PlayFrom(void * jarg1, float jarg2) {
39081   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39082   float arg2 ;
39083
39084   arg1 = (Dali::Animation *)jarg1;
39085   arg2 = (float)jarg2;
39086   {
39087     try {
39088       (arg1)->PlayFrom(arg2);
39089     } catch (std::out_of_range& e) {
39090       {
39091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39092       };
39093     } catch (std::exception& e) {
39094       {
39095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39096       };
39097     } catch (...) {
39098       {
39099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39100       };
39101     }
39102   }
39103 }
39104
39105
39106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Pause(void * jarg1) {
39107   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39108
39109   arg1 = (Dali::Animation *)jarg1;
39110   {
39111     try {
39112       (arg1)->Pause();
39113     } catch (std::out_of_range& e) {
39114       {
39115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39116       };
39117     } catch (std::exception& e) {
39118       {
39119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39120       };
39121     } catch (...) {
39122       {
39123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39124       };
39125     }
39126   }
39127 }
39128
39129
39130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetState(void * jarg1) {
39131   int jresult ;
39132   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39133   Dali::Animation::State result;
39134
39135   arg1 = (Dali::Animation *)jarg1;
39136   {
39137     try {
39138       result = (Dali::Animation::State)((Dali::Animation const *)arg1)->GetState();
39139     } catch (std::out_of_range& e) {
39140       {
39141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39142       };
39143     } catch (std::exception& e) {
39144       {
39145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39146       };
39147     } catch (...) {
39148       {
39149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39150       };
39151     }
39152   }
39153   jresult = (int)result;
39154   return jresult;
39155 }
39156
39157
39158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Stop(void * jarg1) {
39159   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39160
39161   arg1 = (Dali::Animation *)jarg1;
39162   {
39163     try {
39164       (arg1)->Stop();
39165     } catch (std::out_of_range& e) {
39166       {
39167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39168       };
39169     } catch (std::exception& e) {
39170       {
39171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39172       };
39173     } catch (...) {
39174       {
39175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39176       };
39177     }
39178   }
39179 }
39180
39181
39182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Clear(void * jarg1) {
39183   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39184
39185   arg1 = (Dali::Animation *)jarg1;
39186   {
39187     try {
39188       (arg1)->Clear();
39189     } catch (std::out_of_range& e) {
39190       {
39191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39192       };
39193     } catch (std::exception& e) {
39194       {
39195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39196       };
39197     } catch (...) {
39198       {
39199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39200       };
39201     }
39202   }
39203 }
39204
39205
39206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_FinishedSignal(void * jarg1) {
39207   void * jresult ;
39208   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39209   Dali::Animation::AnimationSignalType *result = 0 ;
39210
39211   arg1 = (Dali::Animation *)jarg1;
39212   {
39213     try {
39214       result = (Dali::Animation::AnimationSignalType *) &(arg1)->FinishedSignal();
39215     } catch (std::out_of_range& e) {
39216       {
39217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39218       };
39219     } catch (std::exception& e) {
39220       {
39221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39222       };
39223     } catch (...) {
39224       {
39225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39226       };
39227     }
39228   }
39229   jresult = (void *)result;
39230   return jresult;
39231 }
39232
39233
39234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39235   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39236   SwigValueWrapper< Dali::Property > arg2 ;
39237   Dali::Property::Value arg3 ;
39238   Dali::Property *argp2 ;
39239   Dali::Property::Value *argp3 ;
39240
39241   arg1 = (Dali::Animation *)jarg1;
39242   argp2 = (Dali::Property *)jarg2;
39243   if (!argp2) {
39244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39245     return ;
39246   }
39247   arg2 = *argp2;
39248   argp3 = (Dali::Property::Value *)jarg3;
39249   if (!argp3) {
39250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39251     return ;
39252   }
39253   arg3 = *argp3;
39254   {
39255     try {
39256       (arg1)->AnimateBy(arg2,arg3);
39257     } catch (std::out_of_range& e) {
39258       {
39259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39260       };
39261     } catch (std::exception& e) {
39262       {
39263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39264       };
39265     } catch (...) {
39266       {
39267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39268       };
39269     }
39270   }
39271 }
39272
39273
39274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39275   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39276   SwigValueWrapper< Dali::Property > arg2 ;
39277   Dali::Property::Value arg3 ;
39278   Dali::AlphaFunction arg4 ;
39279   Dali::Property *argp2 ;
39280   Dali::Property::Value *argp3 ;
39281   Dali::AlphaFunction *argp4 ;
39282
39283   arg1 = (Dali::Animation *)jarg1;
39284   argp2 = (Dali::Property *)jarg2;
39285   if (!argp2) {
39286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39287     return ;
39288   }
39289   arg2 = *argp2;
39290   argp3 = (Dali::Property::Value *)jarg3;
39291   if (!argp3) {
39292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39293     return ;
39294   }
39295   arg3 = *argp3;
39296   argp4 = (Dali::AlphaFunction *)jarg4;
39297   if (!argp4) {
39298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39299     return ;
39300   }
39301   arg4 = *argp4;
39302   {
39303     try {
39304       (arg1)->AnimateBy(arg2,arg3,arg4);
39305     } catch (std::out_of_range& e) {
39306       {
39307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39308       };
39309     } catch (std::exception& e) {
39310       {
39311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39312       };
39313     } catch (...) {
39314       {
39315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39316       };
39317     }
39318   }
39319 }
39320
39321
39322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39323   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39324   SwigValueWrapper< Dali::Property > arg2 ;
39325   Dali::Property::Value arg3 ;
39326   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39327   Dali::Property *argp2 ;
39328   Dali::Property::Value *argp3 ;
39329   Dali::TimePeriod *argp4 ;
39330
39331   arg1 = (Dali::Animation *)jarg1;
39332   argp2 = (Dali::Property *)jarg2;
39333   if (!argp2) {
39334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39335     return ;
39336   }
39337   arg2 = *argp2;
39338   argp3 = (Dali::Property::Value *)jarg3;
39339   if (!argp3) {
39340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39341     return ;
39342   }
39343   arg3 = *argp3;
39344   argp4 = (Dali::TimePeriod *)jarg4;
39345   if (!argp4) {
39346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39347     return ;
39348   }
39349   arg4 = *argp4;
39350   {
39351     try {
39352       (arg1)->AnimateBy(arg2,arg3,arg4);
39353     } catch (std::out_of_range& e) {
39354       {
39355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39356       };
39357     } catch (std::exception& e) {
39358       {
39359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39360       };
39361     } catch (...) {
39362       {
39363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39364       };
39365     }
39366   }
39367 }
39368
39369
39370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39371   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39372   SwigValueWrapper< Dali::Property > arg2 ;
39373   Dali::Property::Value arg3 ;
39374   Dali::AlphaFunction arg4 ;
39375   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39376   Dali::Property *argp2 ;
39377   Dali::Property::Value *argp3 ;
39378   Dali::AlphaFunction *argp4 ;
39379   Dali::TimePeriod *argp5 ;
39380
39381   arg1 = (Dali::Animation *)jarg1;
39382   argp2 = (Dali::Property *)jarg2;
39383   if (!argp2) {
39384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39385     return ;
39386   }
39387   arg2 = *argp2;
39388   argp3 = (Dali::Property::Value *)jarg3;
39389   if (!argp3) {
39390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39391     return ;
39392   }
39393   arg3 = *argp3;
39394   argp4 = (Dali::AlphaFunction *)jarg4;
39395   if (!argp4) {
39396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39397     return ;
39398   }
39399   arg4 = *argp4;
39400   argp5 = (Dali::TimePeriod *)jarg5;
39401   if (!argp5) {
39402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39403     return ;
39404   }
39405   arg5 = *argp5;
39406   {
39407     try {
39408       (arg1)->AnimateBy(arg2,arg3,arg4,arg5);
39409     } catch (std::out_of_range& e) {
39410       {
39411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39412       };
39413     } catch (std::exception& e) {
39414       {
39415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39416       };
39417     } catch (...) {
39418       {
39419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39420       };
39421     }
39422   }
39423 }
39424
39425
39426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39427   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39428   SwigValueWrapper< Dali::Property > arg2 ;
39429   Dali::Property::Value arg3 ;
39430   Dali::Property *argp2 ;
39431   Dali::Property::Value *argp3 ;
39432
39433   arg1 = (Dali::Animation *)jarg1;
39434   argp2 = (Dali::Property *)jarg2;
39435   if (!argp2) {
39436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39437     return ;
39438   }
39439   arg2 = *argp2;
39440   argp3 = (Dali::Property::Value *)jarg3;
39441   if (!argp3) {
39442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39443     return ;
39444   }
39445   arg3 = *argp3;
39446   {
39447     try {
39448       (arg1)->AnimateTo(arg2,arg3);
39449     } catch (std::out_of_range& e) {
39450       {
39451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39452       };
39453     } catch (std::exception& e) {
39454       {
39455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39456       };
39457     } catch (...) {
39458       {
39459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39460       };
39461     }
39462   }
39463 }
39464
39465
39466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39467   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39468   SwigValueWrapper< Dali::Property > arg2 ;
39469   Dali::Property::Value arg3 ;
39470   Dali::AlphaFunction arg4 ;
39471   Dali::Property *argp2 ;
39472   Dali::Property::Value *argp3 ;
39473   Dali::AlphaFunction *argp4 ;
39474
39475   arg1 = (Dali::Animation *)jarg1;
39476   argp2 = (Dali::Property *)jarg2;
39477   if (!argp2) {
39478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39479     return ;
39480   }
39481   arg2 = *argp2;
39482   argp3 = (Dali::Property::Value *)jarg3;
39483   if (!argp3) {
39484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39485     return ;
39486   }
39487   arg3 = *argp3;
39488   argp4 = (Dali::AlphaFunction *)jarg4;
39489   if (!argp4) {
39490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39491     return ;
39492   }
39493   arg4 = *argp4;
39494   {
39495     try {
39496       (arg1)->AnimateTo(arg2,arg3,arg4);
39497     } catch (std::out_of_range& e) {
39498       {
39499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39500       };
39501     } catch (std::exception& e) {
39502       {
39503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39504       };
39505     } catch (...) {
39506       {
39507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39508       };
39509     }
39510   }
39511 }
39512
39513
39514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39515   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39516   SwigValueWrapper< Dali::Property > arg2 ;
39517   Dali::Property::Value arg3 ;
39518   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39519   Dali::Property *argp2 ;
39520   Dali::Property::Value *argp3 ;
39521   Dali::TimePeriod *argp4 ;
39522
39523   arg1 = (Dali::Animation *)jarg1;
39524   argp2 = (Dali::Property *)jarg2;
39525   if (!argp2) {
39526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39527     return ;
39528   }
39529   arg2 = *argp2;
39530   argp3 = (Dali::Property::Value *)jarg3;
39531   if (!argp3) {
39532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39533     return ;
39534   }
39535   arg3 = *argp3;
39536   argp4 = (Dali::TimePeriod *)jarg4;
39537   if (!argp4) {
39538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39539     return ;
39540   }
39541   arg4 = *argp4;
39542   {
39543     try {
39544       (arg1)->AnimateTo(arg2,arg3,arg4);
39545     } catch (std::out_of_range& e) {
39546       {
39547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39548       };
39549     } catch (std::exception& e) {
39550       {
39551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39552       };
39553     } catch (...) {
39554       {
39555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39556       };
39557     }
39558   }
39559 }
39560
39561
39562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39563   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39564   SwigValueWrapper< Dali::Property > arg2 ;
39565   Dali::Property::Value arg3 ;
39566   Dali::AlphaFunction arg4 ;
39567   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39568   Dali::Property *argp2 ;
39569   Dali::Property::Value *argp3 ;
39570   Dali::AlphaFunction *argp4 ;
39571   Dali::TimePeriod *argp5 ;
39572
39573   arg1 = (Dali::Animation *)jarg1;
39574   argp2 = (Dali::Property *)jarg2;
39575   if (!argp2) {
39576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39577     return ;
39578   }
39579   arg2 = *argp2;
39580   argp3 = (Dali::Property::Value *)jarg3;
39581   if (!argp3) {
39582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39583     return ;
39584   }
39585   arg3 = *argp3;
39586   argp4 = (Dali::AlphaFunction *)jarg4;
39587   if (!argp4) {
39588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39589     return ;
39590   }
39591   arg4 = *argp4;
39592   argp5 = (Dali::TimePeriod *)jarg5;
39593   if (!argp5) {
39594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39595     return ;
39596   }
39597   arg5 = *argp5;
39598   {
39599     try {
39600       (arg1)->AnimateTo(arg2,arg3,arg4,arg5);
39601     } catch (std::out_of_range& e) {
39602       {
39603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39604       };
39605     } catch (std::exception& e) {
39606       {
39607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39608       };
39609     } catch (...) {
39610       {
39611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39612       };
39613     }
39614   }
39615 }
39616
39617
39618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39619   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39620   SwigValueWrapper< Dali::Property > arg2 ;
39621   Dali::KeyFrames *arg3 = 0 ;
39622   Dali::Property *argp2 ;
39623
39624   arg1 = (Dali::Animation *)jarg1;
39625   argp2 = (Dali::Property *)jarg2;
39626   if (!argp2) {
39627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39628     return ;
39629   }
39630   arg2 = *argp2;
39631   arg3 = (Dali::KeyFrames *)jarg3;
39632   if (!arg3) {
39633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39634     return ;
39635   }
39636   {
39637     try {
39638       (arg1)->AnimateBetween(arg2,*arg3);
39639     } catch (std::out_of_range& e) {
39640       {
39641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39642       };
39643     } catch (std::exception& e) {
39644       {
39645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39646       };
39647     } catch (...) {
39648       {
39649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39650       };
39651     }
39652   }
39653 }
39654
39655
39656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_1(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
39657   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39658   SwigValueWrapper< Dali::Property > arg2 ;
39659   Dali::KeyFrames *arg3 = 0 ;
39660   Dali::Animation::Interpolation arg4 ;
39661   Dali::Property *argp2 ;
39662
39663   arg1 = (Dali::Animation *)jarg1;
39664   argp2 = (Dali::Property *)jarg2;
39665   if (!argp2) {
39666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39667     return ;
39668   }
39669   arg2 = *argp2;
39670   arg3 = (Dali::KeyFrames *)jarg3;
39671   if (!arg3) {
39672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39673     return ;
39674   }
39675   arg4 = (Dali::Animation::Interpolation)jarg4;
39676   {
39677     try {
39678       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39679     } catch (std::out_of_range& e) {
39680       {
39681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39682       };
39683     } catch (std::exception& e) {
39684       {
39685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39686       };
39687     } catch (...) {
39688       {
39689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39690       };
39691     }
39692   }
39693 }
39694
39695
39696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39697   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39698   SwigValueWrapper< Dali::Property > arg2 ;
39699   Dali::KeyFrames *arg3 = 0 ;
39700   Dali::AlphaFunction arg4 ;
39701   Dali::Property *argp2 ;
39702   Dali::AlphaFunction *argp4 ;
39703
39704   arg1 = (Dali::Animation *)jarg1;
39705   argp2 = (Dali::Property *)jarg2;
39706   if (!argp2) {
39707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39708     return ;
39709   }
39710   arg2 = *argp2;
39711   arg3 = (Dali::KeyFrames *)jarg3;
39712   if (!arg3) {
39713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39714     return ;
39715   }
39716   argp4 = (Dali::AlphaFunction *)jarg4;
39717   if (!argp4) {
39718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39719     return ;
39720   }
39721   arg4 = *argp4;
39722   {
39723     try {
39724       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39725     } catch (std::out_of_range& e) {
39726       {
39727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39728       };
39729     } catch (std::exception& e) {
39730       {
39731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39732       };
39733     } catch (...) {
39734       {
39735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39736       };
39737     }
39738   }
39739 }
39740
39741
39742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
39743   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39744   SwigValueWrapper< Dali::Property > arg2 ;
39745   Dali::KeyFrames *arg3 = 0 ;
39746   Dali::AlphaFunction arg4 ;
39747   Dali::Animation::Interpolation arg5 ;
39748   Dali::Property *argp2 ;
39749   Dali::AlphaFunction *argp4 ;
39750
39751   arg1 = (Dali::Animation *)jarg1;
39752   argp2 = (Dali::Property *)jarg2;
39753   if (!argp2) {
39754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39755     return ;
39756   }
39757   arg2 = *argp2;
39758   arg3 = (Dali::KeyFrames *)jarg3;
39759   if (!arg3) {
39760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39761     return ;
39762   }
39763   argp4 = (Dali::AlphaFunction *)jarg4;
39764   if (!argp4) {
39765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39766     return ;
39767   }
39768   arg4 = *argp4;
39769   arg5 = (Dali::Animation::Interpolation)jarg5;
39770   {
39771     try {
39772       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
39773     } catch (std::out_of_range& e) {
39774       {
39775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39776       };
39777     } catch (std::exception& e) {
39778       {
39779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39780       };
39781     } catch (...) {
39782       {
39783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39784       };
39785     }
39786   }
39787 }
39788
39789
39790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39791   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39792   SwigValueWrapper< Dali::Property > arg2 ;
39793   Dali::KeyFrames *arg3 = 0 ;
39794   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39795   Dali::Property *argp2 ;
39796   Dali::TimePeriod *argp4 ;
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   arg3 = (Dali::KeyFrames *)jarg3;
39806   if (!arg3) {
39807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39808     return ;
39809   }
39810   argp4 = (Dali::TimePeriod *)jarg4;
39811   if (!argp4) {
39812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39813     return ;
39814   }
39815   arg4 = *argp4;
39816   {
39817     try {
39818       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39819     } catch (std::out_of_range& e) {
39820       {
39821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39822       };
39823     } catch (std::exception& e) {
39824       {
39825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39826       };
39827     } catch (...) {
39828       {
39829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39830       };
39831     }
39832   }
39833 }
39834
39835
39836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
39837   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39838   SwigValueWrapper< Dali::Property > arg2 ;
39839   Dali::KeyFrames *arg3 = 0 ;
39840   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39841   Dali::Animation::Interpolation arg5 ;
39842   Dali::Property *argp2 ;
39843   Dali::TimePeriod *argp4 ;
39844
39845   arg1 = (Dali::Animation *)jarg1;
39846   argp2 = (Dali::Property *)jarg2;
39847   if (!argp2) {
39848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39849     return ;
39850   }
39851   arg2 = *argp2;
39852   arg3 = (Dali::KeyFrames *)jarg3;
39853   if (!arg3) {
39854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39855     return ;
39856   }
39857   argp4 = (Dali::TimePeriod *)jarg4;
39858   if (!argp4) {
39859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39860     return ;
39861   }
39862   arg4 = *argp4;
39863   arg5 = (Dali::Animation::Interpolation)jarg5;
39864   {
39865     try {
39866       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
39867     } catch (std::out_of_range& e) {
39868       {
39869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39870       };
39871     } catch (std::exception& e) {
39872       {
39873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39874       };
39875     } catch (...) {
39876       {
39877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39878       };
39879     }
39880   }
39881 }
39882
39883
39884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39885   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39886   SwigValueWrapper< Dali::Property > arg2 ;
39887   Dali::KeyFrames *arg3 = 0 ;
39888   Dali::AlphaFunction arg4 ;
39889   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39890   Dali::Property *argp2 ;
39891   Dali::AlphaFunction *argp4 ;
39892   Dali::TimePeriod *argp5 ;
39893
39894   arg1 = (Dali::Animation *)jarg1;
39895   argp2 = (Dali::Property *)jarg2;
39896   if (!argp2) {
39897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39898     return ;
39899   }
39900   arg2 = *argp2;
39901   arg3 = (Dali::KeyFrames *)jarg3;
39902   if (!arg3) {
39903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39904     return ;
39905   }
39906   argp4 = (Dali::AlphaFunction *)jarg4;
39907   if (!argp4) {
39908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39909     return ;
39910   }
39911   arg4 = *argp4;
39912   argp5 = (Dali::TimePeriod *)jarg5;
39913   if (!argp5) {
39914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39915     return ;
39916   }
39917   arg5 = *argp5;
39918   {
39919     try {
39920       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
39921     } catch (std::out_of_range& e) {
39922       {
39923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39924       };
39925     } catch (std::exception& e) {
39926       {
39927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39928       };
39929     } catch (...) {
39930       {
39931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39932       };
39933     }
39934   }
39935 }
39936
39937
39938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_7(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
39939   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39940   SwigValueWrapper< Dali::Property > arg2 ;
39941   Dali::KeyFrames *arg3 = 0 ;
39942   Dali::AlphaFunction arg4 ;
39943   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39944   Dali::Animation::Interpolation arg6 ;
39945   Dali::Property *argp2 ;
39946   Dali::AlphaFunction *argp4 ;
39947   Dali::TimePeriod *argp5 ;
39948
39949   arg1 = (Dali::Animation *)jarg1;
39950   argp2 = (Dali::Property *)jarg2;
39951   if (!argp2) {
39952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39953     return ;
39954   }
39955   arg2 = *argp2;
39956   arg3 = (Dali::KeyFrames *)jarg3;
39957   if (!arg3) {
39958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39959     return ;
39960   }
39961   argp4 = (Dali::AlphaFunction *)jarg4;
39962   if (!argp4) {
39963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39964     return ;
39965   }
39966   arg4 = *argp4;
39967   argp5 = (Dali::TimePeriod *)jarg5;
39968   if (!argp5) {
39969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39970     return ;
39971   }
39972   arg5 = *argp5;
39973   arg6 = (Dali::Animation::Interpolation)jarg6;
39974   {
39975     try {
39976       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5,arg6);
39977     } catch (std::out_of_range& e) {
39978       {
39979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39980       };
39981     } catch (std::exception& e) {
39982       {
39983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39984       };
39985     } catch (...) {
39986       {
39987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39988       };
39989     }
39990   }
39991 }
39992
39993
39994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39995   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39996   Dali::Actor arg2 ;
39997   Dali::Path arg3 ;
39998   Dali::Vector3 *arg4 = 0 ;
39999   Dali::Actor *argp2 ;
40000   Dali::Path *argp3 ;
40001
40002   arg1 = (Dali::Animation *)jarg1;
40003   argp2 = (Dali::Actor *)jarg2;
40004   if (!argp2) {
40005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40006     return ;
40007   }
40008   arg2 = *argp2;
40009   argp3 = (Dali::Path *)jarg3;
40010   if (!argp3) {
40011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40012     return ;
40013   }
40014   arg3 = *argp3;
40015   arg4 = (Dali::Vector3 *)jarg4;
40016   if (!arg4) {
40017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40018     return ;
40019   }
40020   {
40021     try {
40022       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4);
40023     } catch (std::out_of_range& e) {
40024       {
40025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40026       };
40027     } catch (std::exception& e) {
40028       {
40029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40030       };
40031     } catch (...) {
40032       {
40033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40034       };
40035     }
40036   }
40037 }
40038
40039
40040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40041   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40042   Dali::Actor arg2 ;
40043   Dali::Path arg3 ;
40044   Dali::Vector3 *arg4 = 0 ;
40045   Dali::AlphaFunction arg5 ;
40046   Dali::Actor *argp2 ;
40047   Dali::Path *argp3 ;
40048   Dali::AlphaFunction *argp5 ;
40049
40050   arg1 = (Dali::Animation *)jarg1;
40051   argp2 = (Dali::Actor *)jarg2;
40052   if (!argp2) {
40053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40054     return ;
40055   }
40056   arg2 = *argp2;
40057   argp3 = (Dali::Path *)jarg3;
40058   if (!argp3) {
40059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40060     return ;
40061   }
40062   arg3 = *argp3;
40063   arg4 = (Dali::Vector3 *)jarg4;
40064   if (!arg4) {
40065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40066     return ;
40067   }
40068   argp5 = (Dali::AlphaFunction *)jarg5;
40069   if (!argp5) {
40070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40071     return ;
40072   }
40073   arg5 = *argp5;
40074   {
40075     try {
40076       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
40077     } catch (std::out_of_range& e) {
40078       {
40079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40080       };
40081     } catch (std::exception& e) {
40082       {
40083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40084       };
40085     } catch (...) {
40086       {
40087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40088       };
40089     }
40090   }
40091 }
40092
40093
40094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40095   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40096   Dali::Actor arg2 ;
40097   Dali::Path arg3 ;
40098   Dali::Vector3 *arg4 = 0 ;
40099   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40100   Dali::Actor *argp2 ;
40101   Dali::Path *argp3 ;
40102   Dali::TimePeriod *argp5 ;
40103
40104   arg1 = (Dali::Animation *)jarg1;
40105   argp2 = (Dali::Actor *)jarg2;
40106   if (!argp2) {
40107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40108     return ;
40109   }
40110   arg2 = *argp2;
40111   argp3 = (Dali::Path *)jarg3;
40112   if (!argp3) {
40113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40114     return ;
40115   }
40116   arg3 = *argp3;
40117   arg4 = (Dali::Vector3 *)jarg4;
40118   if (!arg4) {
40119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40120     return ;
40121   }
40122   argp5 = (Dali::TimePeriod *)jarg5;
40123   if (!argp5) {
40124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40125     return ;
40126   }
40127   arg5 = *argp5;
40128   {
40129     try {
40130       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
40131     } catch (std::out_of_range& e) {
40132       {
40133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40134       };
40135     } catch (std::exception& e) {
40136       {
40137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40138       };
40139     } catch (...) {
40140       {
40141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40142       };
40143     }
40144   }
40145 }
40146
40147
40148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
40149   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40150   Dali::Actor arg2 ;
40151   Dali::Path arg3 ;
40152   Dali::Vector3 *arg4 = 0 ;
40153   Dali::AlphaFunction arg5 ;
40154   SwigValueWrapper< Dali::TimePeriod > arg6 ;
40155   Dali::Actor *argp2 ;
40156   Dali::Path *argp3 ;
40157   Dali::AlphaFunction *argp5 ;
40158   Dali::TimePeriod *argp6 ;
40159
40160   arg1 = (Dali::Animation *)jarg1;
40161   argp2 = (Dali::Actor *)jarg2;
40162   if (!argp2) {
40163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40164     return ;
40165   }
40166   arg2 = *argp2;
40167   argp3 = (Dali::Path *)jarg3;
40168   if (!argp3) {
40169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40170     return ;
40171   }
40172   arg3 = *argp3;
40173   arg4 = (Dali::Vector3 *)jarg4;
40174   if (!arg4) {
40175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40176     return ;
40177   }
40178   argp5 = (Dali::AlphaFunction *)jarg5;
40179   if (!argp5) {
40180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40181     return ;
40182   }
40183   arg5 = *argp5;
40184   argp6 = (Dali::TimePeriod *)jarg6;
40185   if (!argp6) {
40186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40187     return ;
40188   }
40189   arg6 = *argp6;
40190   {
40191     try {
40192       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5,arg6);
40193     } catch (std::out_of_range& e) {
40194       {
40195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40196       };
40197     } catch (std::exception& e) {
40198       {
40199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40200       };
40201     } catch (...) {
40202       {
40203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40204       };
40205     }
40206   }
40207 }
40208
40209
40210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Show(void * jarg1, void * jarg2, float jarg3) {
40211   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40212   Dali::Actor arg2 ;
40213   float arg3 ;
40214   Dali::Actor *argp2 ;
40215
40216   arg1 = (Dali::Animation *)jarg1;
40217   argp2 = (Dali::Actor *)jarg2;
40218   if (!argp2) {
40219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40220     return ;
40221   }
40222   arg2 = *argp2;
40223   arg3 = (float)jarg3;
40224   {
40225     try {
40226       (arg1)->Show(arg2,arg3);
40227     } catch (std::out_of_range& e) {
40228       {
40229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40230       };
40231     } catch (std::exception& e) {
40232       {
40233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40234       };
40235     } catch (...) {
40236       {
40237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40238       };
40239     }
40240   }
40241 }
40242
40243
40244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Hide(void * jarg1, void * jarg2, float jarg3) {
40245   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40246   Dali::Actor arg2 ;
40247   float arg3 ;
40248   Dali::Actor *argp2 ;
40249
40250   arg1 = (Dali::Animation *)jarg1;
40251   argp2 = (Dali::Actor *)jarg2;
40252   if (!argp2) {
40253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40254     return ;
40255   }
40256   arg2 = *argp2;
40257   arg3 = (float)jarg3;
40258   {
40259     try {
40260       (arg1)->Hide(arg2,arg3);
40261     } catch (std::out_of_range& e) {
40262       {
40263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40264       };
40265     } catch (std::exception& e) {
40266       {
40267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40268       };
40269     } catch (...) {
40270       {
40271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40272       };
40273     }
40274   }
40275 }
40276
40277
40278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
40279   int jresult ;
40280   int result;
40281
40282   result = (int)Dali::LinearConstrainer::Property::VALUE;
40283   jresult = (int)result;
40284   return jresult;
40285 }
40286
40287
40288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
40289   int jresult ;
40290   int result;
40291
40292   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
40293   jresult = (int)result;
40294   return jresult;
40295 }
40296
40297
40298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
40299   void * jresult ;
40300   Dali::LinearConstrainer::Property *result = 0 ;
40301
40302   {
40303     try {
40304       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
40305     } catch (std::out_of_range& e) {
40306       {
40307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40308       };
40309     } catch (std::exception& e) {
40310       {
40311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40312       };
40313     } catch (...) {
40314       {
40315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40316       };
40317     }
40318   }
40319   jresult = (void *)result;
40320   return jresult;
40321 }
40322
40323
40324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
40325   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
40326
40327   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
40328   {
40329     try {
40330       delete arg1;
40331     } catch (std::out_of_range& e) {
40332       {
40333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40334       };
40335     } catch (std::exception& e) {
40336       {
40337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40338       };
40339     } catch (...) {
40340       {
40341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40342       };
40343     }
40344   }
40345 }
40346
40347
40348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
40349   void * jresult ;
40350   Dali::LinearConstrainer result;
40351
40352   {
40353     try {
40354       result = Dali::LinearConstrainer::New();
40355     } catch (std::out_of_range& e) {
40356       {
40357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40358       };
40359     } catch (std::exception& e) {
40360       {
40361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40362       };
40363     } catch (...) {
40364       {
40365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40366       };
40367     }
40368   }
40369   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40370   return jresult;
40371 }
40372
40373
40374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
40375   void * jresult ;
40376   Dali::BaseHandle arg1 ;
40377   Dali::BaseHandle *argp1 ;
40378   Dali::LinearConstrainer result;
40379
40380   argp1 = (Dali::BaseHandle *)jarg1;
40381   if (!argp1) {
40382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40383     return 0;
40384   }
40385   arg1 = *argp1;
40386   {
40387     try {
40388       result = Dali::LinearConstrainer::DownCast(arg1);
40389     } catch (std::out_of_range& e) {
40390       {
40391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40392       };
40393     } catch (std::exception& e) {
40394       {
40395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40396       };
40397     } catch (...) {
40398       {
40399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40400       };
40401     }
40402   }
40403   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40404   return jresult;
40405 }
40406
40407
40408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
40409   void * jresult ;
40410   Dali::LinearConstrainer *result = 0 ;
40411
40412   {
40413     try {
40414       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
40415     } catch (std::out_of_range& e) {
40416       {
40417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40418       };
40419     } catch (std::exception& e) {
40420       {
40421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40422       };
40423     } catch (...) {
40424       {
40425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40426       };
40427     }
40428   }
40429   jresult = (void *)result;
40430   return jresult;
40431 }
40432
40433
40434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
40435   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40436
40437   arg1 = (Dali::LinearConstrainer *)jarg1;
40438   {
40439     try {
40440       delete arg1;
40441     } catch (std::out_of_range& e) {
40442       {
40443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40444       };
40445     } catch (std::exception& e) {
40446       {
40447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40448       };
40449     } catch (...) {
40450       {
40451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40452       };
40453     }
40454   }
40455 }
40456
40457
40458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
40459   void * jresult ;
40460   Dali::LinearConstrainer *arg1 = 0 ;
40461   Dali::LinearConstrainer *result = 0 ;
40462
40463   arg1 = (Dali::LinearConstrainer *)jarg1;
40464   if (!arg1) {
40465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40466     return 0;
40467   }
40468   {
40469     try {
40470       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
40471     } catch (std::out_of_range& e) {
40472       {
40473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40474       };
40475     } catch (std::exception& e) {
40476       {
40477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40478       };
40479     } catch (...) {
40480       {
40481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40482       };
40483     }
40484   }
40485   jresult = (void *)result;
40486   return jresult;
40487 }
40488
40489
40490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
40491   void * jresult ;
40492   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40493   Dali::LinearConstrainer *arg2 = 0 ;
40494   Dali::LinearConstrainer *result = 0 ;
40495
40496   arg1 = (Dali::LinearConstrainer *)jarg1;
40497   arg2 = (Dali::LinearConstrainer *)jarg2;
40498   if (!arg2) {
40499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40500     return 0;
40501   }
40502   {
40503     try {
40504       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
40505     } catch (std::out_of_range& e) {
40506       {
40507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40508       };
40509     } catch (std::exception& e) {
40510       {
40511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40512       };
40513     } catch (...) {
40514       {
40515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40516       };
40517     }
40518   }
40519   jresult = (void *)result;
40520   return jresult;
40521 }
40522
40523
40524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40525   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40526   SwigValueWrapper< Dali::Property > arg2 ;
40527   SwigValueWrapper< Dali::Property > arg3 ;
40528   Dali::Vector2 *arg4 = 0 ;
40529   Dali::Vector2 *arg5 = 0 ;
40530   Dali::Property *argp2 ;
40531   Dali::Property *argp3 ;
40532
40533   arg1 = (Dali::LinearConstrainer *)jarg1;
40534   argp2 = (Dali::Property *)jarg2;
40535   if (!argp2) {
40536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40537     return ;
40538   }
40539   arg2 = *argp2;
40540   argp3 = (Dali::Property *)jarg3;
40541   if (!argp3) {
40542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40543     return ;
40544   }
40545   arg3 = *argp3;
40546   arg4 = (Dali::Vector2 *)jarg4;
40547   if (!arg4) {
40548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40549     return ;
40550   }
40551   arg5 = (Dali::Vector2 *)jarg5;
40552   if (!arg5) {
40553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40554     return ;
40555   }
40556   {
40557     try {
40558       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
40559     } catch (std::out_of_range& e) {
40560       {
40561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40562       };
40563     } catch (std::exception& e) {
40564       {
40565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40566       };
40567     } catch (...) {
40568       {
40569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40570       };
40571     }
40572   }
40573 }
40574
40575
40576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40577   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40578   SwigValueWrapper< Dali::Property > arg2 ;
40579   SwigValueWrapper< Dali::Property > arg3 ;
40580   Dali::Vector2 *arg4 = 0 ;
40581   Dali::Property *argp2 ;
40582   Dali::Property *argp3 ;
40583
40584   arg1 = (Dali::LinearConstrainer *)jarg1;
40585   argp2 = (Dali::Property *)jarg2;
40586   if (!argp2) {
40587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40588     return ;
40589   }
40590   arg2 = *argp2;
40591   argp3 = (Dali::Property *)jarg3;
40592   if (!argp3) {
40593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40594     return ;
40595   }
40596   arg3 = *argp3;
40597   arg4 = (Dali::Vector2 *)jarg4;
40598   if (!arg4) {
40599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40600     return ;
40601   }
40602   {
40603     try {
40604       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
40605     } catch (std::out_of_range& e) {
40606       {
40607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40608       };
40609     } catch (std::exception& e) {
40610       {
40611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40612       };
40613     } catch (...) {
40614       {
40615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40616       };
40617     }
40618   }
40619 }
40620
40621
40622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
40623   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40624   Dali::Handle *arg2 = 0 ;
40625
40626   arg1 = (Dali::LinearConstrainer *)jarg1;
40627   arg2 = (Dali::Handle *)jarg2;
40628   if (!arg2) {
40629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
40630     return ;
40631   }
40632   {
40633     try {
40634       (arg1)->Remove(*arg2);
40635     } catch (std::out_of_range& e) {
40636       {
40637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40638       };
40639     } catch (std::exception& e) {
40640       {
40641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40642       };
40643     } catch (...) {
40644       {
40645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40646       };
40647     }
40648   }
40649 }
40650
40651
40652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
40653   int jresult ;
40654   int result;
40655
40656   result = (int)Dali::PathConstrainer::Property::FORWARD;
40657   jresult = (int)result;
40658   return jresult;
40659 }
40660
40661
40662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
40663   int jresult ;
40664   int result;
40665
40666   result = (int)Dali::PathConstrainer::Property::POINTS;
40667   jresult = (int)result;
40668   return jresult;
40669 }
40670
40671
40672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
40673   int jresult ;
40674   int result;
40675
40676   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
40677   jresult = (int)result;
40678   return jresult;
40679 }
40680
40681
40682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
40683   void * jresult ;
40684   Dali::PathConstrainer::Property *result = 0 ;
40685
40686   {
40687     try {
40688       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
40689     } catch (std::out_of_range& e) {
40690       {
40691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40692       };
40693     } catch (std::exception& e) {
40694       {
40695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40696       };
40697     } catch (...) {
40698       {
40699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40700       };
40701     }
40702   }
40703   jresult = (void *)result;
40704   return jresult;
40705 }
40706
40707
40708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
40709   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
40710
40711   arg1 = (Dali::PathConstrainer::Property *)jarg1;
40712   {
40713     try {
40714       delete arg1;
40715     } catch (std::out_of_range& e) {
40716       {
40717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40718       };
40719     } catch (std::exception& e) {
40720       {
40721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40722       };
40723     } catch (...) {
40724       {
40725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40726       };
40727     }
40728   }
40729 }
40730
40731
40732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
40733   void * jresult ;
40734   Dali::PathConstrainer result;
40735
40736   {
40737     try {
40738       result = Dali::PathConstrainer::New();
40739     } catch (std::out_of_range& e) {
40740       {
40741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40742       };
40743     } catch (std::exception& e) {
40744       {
40745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40746       };
40747     } catch (...) {
40748       {
40749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40750       };
40751     }
40752   }
40753   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
40754   return jresult;
40755 }
40756
40757
40758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
40759   void * jresult ;
40760   Dali::BaseHandle arg1 ;
40761   Dali::BaseHandle *argp1 ;
40762   Dali::PathConstrainer result;
40763
40764   argp1 = (Dali::BaseHandle *)jarg1;
40765   if (!argp1) {
40766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40767     return 0;
40768   }
40769   arg1 = *argp1;
40770   {
40771     try {
40772       result = Dali::PathConstrainer::DownCast(arg1);
40773     } catch (std::out_of_range& e) {
40774       {
40775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40776       };
40777     } catch (std::exception& e) {
40778       {
40779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40780       };
40781     } catch (...) {
40782       {
40783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40784       };
40785     }
40786   }
40787   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
40788   return jresult;
40789 }
40790
40791
40792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
40793   void * jresult ;
40794   Dali::PathConstrainer *result = 0 ;
40795
40796   {
40797     try {
40798       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
40799     } catch (std::out_of_range& e) {
40800       {
40801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40802       };
40803     } catch (std::exception& e) {
40804       {
40805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40806       };
40807     } catch (...) {
40808       {
40809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40810       };
40811     }
40812   }
40813   jresult = (void *)result;
40814   return jresult;
40815 }
40816
40817
40818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
40819   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40820
40821   arg1 = (Dali::PathConstrainer *)jarg1;
40822   {
40823     try {
40824       delete arg1;
40825     } catch (std::out_of_range& e) {
40826       {
40827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40828       };
40829     } catch (std::exception& e) {
40830       {
40831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40832       };
40833     } catch (...) {
40834       {
40835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40836       };
40837     }
40838   }
40839 }
40840
40841
40842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
40843   void * jresult ;
40844   Dali::PathConstrainer *arg1 = 0 ;
40845   Dali::PathConstrainer *result = 0 ;
40846
40847   arg1 = (Dali::PathConstrainer *)jarg1;
40848   if (!arg1) {
40849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
40850     return 0;
40851   }
40852   {
40853     try {
40854       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
40855     } catch (std::out_of_range& e) {
40856       {
40857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40858       };
40859     } catch (std::exception& e) {
40860       {
40861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40862       };
40863     } catch (...) {
40864       {
40865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40866       };
40867     }
40868   }
40869   jresult = (void *)result;
40870   return jresult;
40871 }
40872
40873
40874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
40875   void * jresult ;
40876   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40877   Dali::PathConstrainer *arg2 = 0 ;
40878   Dali::PathConstrainer *result = 0 ;
40879
40880   arg1 = (Dali::PathConstrainer *)jarg1;
40881   arg2 = (Dali::PathConstrainer *)jarg2;
40882   if (!arg2) {
40883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
40884     return 0;
40885   }
40886   {
40887     try {
40888       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
40889     } catch (std::out_of_range& e) {
40890       {
40891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40892       };
40893     } catch (std::exception& e) {
40894       {
40895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40896       };
40897     } catch (...) {
40898       {
40899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40900       };
40901     }
40902   }
40903   jresult = (void *)result;
40904   return jresult;
40905 }
40906
40907
40908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40909   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40910   SwigValueWrapper< Dali::Property > arg2 ;
40911   SwigValueWrapper< Dali::Property > arg3 ;
40912   Dali::Vector2 *arg4 = 0 ;
40913   Dali::Vector2 *arg5 = 0 ;
40914   Dali::Property *argp2 ;
40915   Dali::Property *argp3 ;
40916
40917   arg1 = (Dali::PathConstrainer *)jarg1;
40918   argp2 = (Dali::Property *)jarg2;
40919   if (!argp2) {
40920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40921     return ;
40922   }
40923   arg2 = *argp2;
40924   argp3 = (Dali::Property *)jarg3;
40925   if (!argp3) {
40926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40927     return ;
40928   }
40929   arg3 = *argp3;
40930   arg4 = (Dali::Vector2 *)jarg4;
40931   if (!arg4) {
40932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40933     return ;
40934   }
40935   arg5 = (Dali::Vector2 *)jarg5;
40936   if (!arg5) {
40937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40938     return ;
40939   }
40940   {
40941     try {
40942       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
40943     } catch (std::out_of_range& e) {
40944       {
40945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40946       };
40947     } catch (std::exception& e) {
40948       {
40949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40950       };
40951     } catch (...) {
40952       {
40953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40954       };
40955     }
40956   }
40957 }
40958
40959
40960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40961   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40962   SwigValueWrapper< Dali::Property > arg2 ;
40963   SwigValueWrapper< Dali::Property > arg3 ;
40964   Dali::Vector2 *arg4 = 0 ;
40965   Dali::Property *argp2 ;
40966   Dali::Property *argp3 ;
40967
40968   arg1 = (Dali::PathConstrainer *)jarg1;
40969   argp2 = (Dali::Property *)jarg2;
40970   if (!argp2) {
40971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40972     return ;
40973   }
40974   arg2 = *argp2;
40975   argp3 = (Dali::Property *)jarg3;
40976   if (!argp3) {
40977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40978     return ;
40979   }
40980   arg3 = *argp3;
40981   arg4 = (Dali::Vector2 *)jarg4;
40982   if (!arg4) {
40983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40984     return ;
40985   }
40986   {
40987     try {
40988       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
40989     } catch (std::out_of_range& e) {
40990       {
40991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40992       };
40993     } catch (std::exception& e) {
40994       {
40995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40996       };
40997     } catch (...) {
40998       {
40999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41000       };
41001     }
41002   }
41003 }
41004
41005
41006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
41007   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41008   Dali::Handle *arg2 = 0 ;
41009
41010   arg1 = (Dali::PathConstrainer *)jarg1;
41011   arg2 = (Dali::Handle *)jarg2;
41012   if (!arg2) {
41013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
41014     return ;
41015   }
41016   {
41017     try {
41018       (arg1)->Remove(*arg2);
41019     } catch (std::out_of_range& e) {
41020       {
41021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41022       };
41023     } catch (std::exception& e) {
41024       {
41025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41026       };
41027     } catch (...) {
41028       {
41029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41030       };
41031     }
41032   }
41033 }
41034
41035
41036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
41037   int jresult ;
41038   Dali::FittingMode::Type result;
41039
41040   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
41041   jresult = (int)result;
41042   return jresult;
41043 }
41044
41045
41046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
41047   int jresult ;
41048   Dali::SamplingMode::Type result;
41049
41050   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
41051   jresult = (int)result;
41052   return jresult;
41053 }
41054
41055
41056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
41057   void * jresult ;
41058   Dali::BufferImage *result = 0 ;
41059
41060   {
41061     try {
41062       result = (Dali::BufferImage *)new Dali::BufferImage();
41063     } catch (std::out_of_range& e) {
41064       {
41065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41066       };
41067     } catch (std::exception& e) {
41068       {
41069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41070       };
41071     } catch (...) {
41072       {
41073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41074       };
41075     }
41076   }
41077   jresult = (void *)result;
41078   return jresult;
41079 }
41080
41081
41082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
41083   void * jresult ;
41084   unsigned int arg1 ;
41085   unsigned int arg2 ;
41086   Dali::Pixel::Format arg3 ;
41087   Dali::BufferImage result;
41088
41089   arg1 = (unsigned int)jarg1;
41090   arg2 = (unsigned int)jarg2;
41091   arg3 = (Dali::Pixel::Format)jarg3;
41092   {
41093     try {
41094       result = Dali::BufferImage::New(arg1,arg2,arg3);
41095     } catch (std::out_of_range& e) {
41096       {
41097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41098       };
41099     } catch (std::exception& e) {
41100       {
41101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41102       };
41103     } catch (...) {
41104       {
41105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41106       };
41107     }
41108   }
41109   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41110   return jresult;
41111 }
41112
41113
41114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
41115   void * jresult ;
41116   unsigned int arg1 ;
41117   unsigned int arg2 ;
41118   Dali::BufferImage result;
41119
41120   arg1 = (unsigned int)jarg1;
41121   arg2 = (unsigned int)jarg2;
41122   {
41123     try {
41124       result = Dali::BufferImage::New(arg1,arg2);
41125     } catch (std::out_of_range& e) {
41126       {
41127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41128       };
41129     } catch (std::exception& e) {
41130       {
41131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41132       };
41133     } catch (...) {
41134       {
41135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41136       };
41137     }
41138   }
41139   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41140   return jresult;
41141 }
41142
41143
41144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
41145   void * jresult ;
41146   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41147   unsigned int arg2 ;
41148   unsigned int arg3 ;
41149   Dali::Pixel::Format arg4 ;
41150   unsigned int arg5 ;
41151   Dali::BufferImage result;
41152
41153   arg1 = jarg1;
41154   arg2 = (unsigned int)jarg2;
41155   arg3 = (unsigned int)jarg3;
41156   arg4 = (Dali::Pixel::Format)jarg4;
41157   arg5 = (unsigned int)jarg5;
41158   {
41159     try {
41160       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
41161     } catch (std::out_of_range& e) {
41162       {
41163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41164       };
41165     } catch (std::exception& e) {
41166       {
41167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41168       };
41169     } catch (...) {
41170       {
41171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41172       };
41173     }
41174   }
41175   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41176
41177
41178   return jresult;
41179 }
41180
41181
41182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
41183   void * jresult ;
41184   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41185   unsigned int arg2 ;
41186   unsigned int arg3 ;
41187   Dali::Pixel::Format arg4 ;
41188   Dali::BufferImage result;
41189
41190   arg1 = jarg1;
41191   arg2 = (unsigned int)jarg2;
41192   arg3 = (unsigned int)jarg3;
41193   arg4 = (Dali::Pixel::Format)jarg4;
41194   {
41195     try {
41196       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
41197     } catch (std::out_of_range& e) {
41198       {
41199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41200       };
41201     } catch (std::exception& e) {
41202       {
41203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41204       };
41205     } catch (...) {
41206       {
41207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41208       };
41209     }
41210   }
41211   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41212
41213
41214   return jresult;
41215 }
41216
41217
41218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
41219   void * jresult ;
41220   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41221   unsigned int arg2 ;
41222   unsigned int arg3 ;
41223   Dali::BufferImage result;
41224
41225   arg1 = jarg1;
41226   arg2 = (unsigned int)jarg2;
41227   arg3 = (unsigned int)jarg3;
41228   {
41229     try {
41230       result = Dali::BufferImage::New(arg1,arg2,arg3);
41231     } catch (std::out_of_range& e) {
41232       {
41233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41234       };
41235     } catch (std::exception& e) {
41236       {
41237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41238       };
41239     } catch (...) {
41240       {
41241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41242       };
41243     }
41244   }
41245   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41246
41247
41248   return jresult;
41249 }
41250
41251
41252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
41253   void * jresult ;
41254   Dali::BaseHandle arg1 ;
41255   Dali::BaseHandle *argp1 ;
41256   Dali::BufferImage result;
41257
41258   argp1 = (Dali::BaseHandle *)jarg1;
41259   if (!argp1) {
41260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41261     return 0;
41262   }
41263   arg1 = *argp1;
41264   {
41265     try {
41266       result = Dali::BufferImage::DownCast(arg1);
41267     } catch (std::out_of_range& e) {
41268       {
41269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41270       };
41271     } catch (std::exception& e) {
41272       {
41273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41274       };
41275     } catch (...) {
41276       {
41277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41278       };
41279     }
41280   }
41281   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41282   return jresult;
41283 }
41284
41285
41286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
41287   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41288
41289   arg1 = (Dali::BufferImage *)jarg1;
41290   {
41291     try {
41292       delete arg1;
41293     } catch (std::out_of_range& e) {
41294       {
41295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41296       };
41297     } catch (std::exception& e) {
41298       {
41299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41300       };
41301     } catch (...) {
41302       {
41303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41304       };
41305     }
41306   }
41307 }
41308
41309
41310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
41311   void * jresult ;
41312   Dali::BufferImage *arg1 = 0 ;
41313   Dali::BufferImage *result = 0 ;
41314
41315   arg1 = (Dali::BufferImage *)jarg1;
41316   if (!arg1) {
41317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41318     return 0;
41319   }
41320   {
41321     try {
41322       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
41323     } catch (std::out_of_range& e) {
41324       {
41325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41326       };
41327     } catch (std::exception& e) {
41328       {
41329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41330       };
41331     } catch (...) {
41332       {
41333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41334       };
41335     }
41336   }
41337   jresult = (void *)result;
41338   return jresult;
41339 }
41340
41341
41342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
41343   void * jresult ;
41344   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41345   Dali::BufferImage *arg2 = 0 ;
41346   Dali::BufferImage *result = 0 ;
41347
41348   arg1 = (Dali::BufferImage *)jarg1;
41349   arg2 = (Dali::BufferImage *)jarg2;
41350   if (!arg2) {
41351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41352     return 0;
41353   }
41354   {
41355     try {
41356       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
41357     } catch (std::out_of_range& e) {
41358       {
41359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41360       };
41361     } catch (std::exception& e) {
41362       {
41363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41364       };
41365     } catch (...) {
41366       {
41367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41368       };
41369     }
41370   }
41371   jresult = (void *)result;
41372   return jresult;
41373 }
41374
41375
41376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
41377   void * jresult ;
41378   Dali::BufferImage result;
41379
41380   {
41381     try {
41382       result = Dali::BufferImage::WHITE();
41383     } catch (std::out_of_range& e) {
41384       {
41385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41386       };
41387     } catch (std::exception& e) {
41388       {
41389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41390       };
41391     } catch (...) {
41392       {
41393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41394       };
41395     }
41396   }
41397   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41398   return jresult;
41399 }
41400
41401
41402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
41403   void * jresult ;
41404   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41405   Dali::PixelBuffer *result = 0 ;
41406
41407   arg1 = (Dali::BufferImage *)jarg1;
41408   {
41409     try {
41410       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
41411     } catch (std::out_of_range& e) {
41412       {
41413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41414       };
41415     } catch (std::exception& e) {
41416       {
41417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41418       };
41419     } catch (...) {
41420       {
41421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41422       };
41423     }
41424   }
41425   jresult = (void *)result;
41426   return jresult;
41427 }
41428
41429
41430 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
41431   unsigned int jresult ;
41432   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41433   unsigned int result;
41434
41435   arg1 = (Dali::BufferImage *)jarg1;
41436   {
41437     try {
41438       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
41439     } catch (std::out_of_range& e) {
41440       {
41441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41442       };
41443     } catch (std::exception& e) {
41444       {
41445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41446       };
41447     } catch (...) {
41448       {
41449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41450       };
41451     }
41452   }
41453   jresult = result;
41454   return jresult;
41455 }
41456
41457
41458 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
41459   unsigned int jresult ;
41460   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41461   unsigned int result;
41462
41463   arg1 = (Dali::BufferImage *)jarg1;
41464   {
41465     try {
41466       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
41467     } catch (std::out_of_range& e) {
41468       {
41469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41470       };
41471     } catch (std::exception& e) {
41472       {
41473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41474       };
41475     } catch (...) {
41476       {
41477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41478       };
41479     }
41480   }
41481   jresult = result;
41482   return jresult;
41483 }
41484
41485
41486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
41487   int jresult ;
41488   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41489   Dali::Pixel::Format result;
41490
41491   arg1 = (Dali::BufferImage *)jarg1;
41492   {
41493     try {
41494       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
41495     } catch (std::out_of_range& e) {
41496       {
41497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41498       };
41499     } catch (std::exception& e) {
41500       {
41501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41502       };
41503     } catch (...) {
41504       {
41505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41506       };
41507     }
41508   }
41509   jresult = (int)result;
41510   return jresult;
41511 }
41512
41513
41514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
41515   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41516
41517   arg1 = (Dali::BufferImage *)jarg1;
41518   {
41519     try {
41520       (arg1)->Update();
41521     } catch (std::out_of_range& e) {
41522       {
41523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41524       };
41525     } catch (std::exception& e) {
41526       {
41527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41528       };
41529     } catch (...) {
41530       {
41531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41532       };
41533     }
41534   }
41535 }
41536
41537
41538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
41539   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41540   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
41541   Dali::RectArea *argp2 ;
41542
41543   arg1 = (Dali::BufferImage *)jarg1;
41544   argp2 = (Dali::RectArea *)jarg2;
41545   if (!argp2) {
41546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
41547     return ;
41548   }
41549   arg2 = *argp2;
41550   {
41551     try {
41552       (arg1)->Update(arg2);
41553     } catch (std::out_of_range& e) {
41554       {
41555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41556       };
41557     } catch (std::exception& e) {
41558       {
41559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41560       };
41561     } catch (...) {
41562       {
41563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41564       };
41565     }
41566   }
41567 }
41568
41569
41570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
41571   unsigned int jresult ;
41572   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41573   bool result;
41574
41575   arg1 = (Dali::BufferImage *)jarg1;
41576   {
41577     try {
41578       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
41579     } catch (std::out_of_range& e) {
41580       {
41581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41582       };
41583     } catch (std::exception& e) {
41584       {
41585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41586       };
41587     } catch (...) {
41588       {
41589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41590       };
41591     }
41592   }
41593   jresult = result;
41594   return jresult;
41595 }
41596
41597
41598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
41599   void * jresult ;
41600   Dali::EncodedBufferImage *result = 0 ;
41601
41602   {
41603     try {
41604       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
41605     } catch (std::out_of_range& e) {
41606       {
41607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41608       };
41609     } catch (std::exception& e) {
41610       {
41611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41612       };
41613     } catch (...) {
41614       {
41615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41616       };
41617     }
41618   }
41619   jresult = (void *)result;
41620   return jresult;
41621 }
41622
41623
41624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
41625   void * jresult ;
41626   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41627   std::size_t arg2 ;
41628   Dali::EncodedBufferImage result;
41629
41630   arg1 = (uint8_t *)jarg1;
41631   arg2 = (std::size_t)jarg2;
41632   {
41633     try {
41634       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
41635     } catch (std::out_of_range& e) {
41636       {
41637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41638       };
41639     } catch (std::exception& e) {
41640       {
41641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41642       };
41643     } catch (...) {
41644       {
41645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41646       };
41647     }
41648   }
41649   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41650   return jresult;
41651 }
41652
41653
41654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
41655   void * jresult ;
41656   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41657   std::size_t arg2 ;
41658   Dali::ImageDimensions arg3 ;
41659   Dali::FittingMode::Type arg4 ;
41660   Dali::SamplingMode::Type arg5 ;
41661   bool arg6 ;
41662   Dali::ImageDimensions *argp3 ;
41663   Dali::EncodedBufferImage result;
41664
41665   arg1 = (uint8_t *)jarg1;
41666   arg2 = (std::size_t)jarg2;
41667   argp3 = (Dali::ImageDimensions *)jarg3;
41668   if (!argp3) {
41669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41670     return 0;
41671   }
41672   arg3 = *argp3;
41673   arg4 = (Dali::FittingMode::Type)jarg4;
41674   arg5 = (Dali::SamplingMode::Type)jarg5;
41675   arg6 = jarg6 ? true : false;
41676   {
41677     try {
41678       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
41679     } catch (std::out_of_range& e) {
41680       {
41681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41682       };
41683     } catch (std::exception& e) {
41684       {
41685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41686       };
41687     } catch (...) {
41688       {
41689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41690       };
41691     }
41692   }
41693   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41694   return jresult;
41695 }
41696
41697
41698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
41699   void * jresult ;
41700   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41701   std::size_t arg2 ;
41702   Dali::ImageDimensions arg3 ;
41703   Dali::FittingMode::Type arg4 ;
41704   Dali::SamplingMode::Type arg5 ;
41705   Dali::ImageDimensions *argp3 ;
41706   Dali::EncodedBufferImage result;
41707
41708   arg1 = (uint8_t *)jarg1;
41709   arg2 = (std::size_t)jarg2;
41710   argp3 = (Dali::ImageDimensions *)jarg3;
41711   if (!argp3) {
41712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41713     return 0;
41714   }
41715   arg3 = *argp3;
41716   arg4 = (Dali::FittingMode::Type)jarg4;
41717   arg5 = (Dali::SamplingMode::Type)jarg5;
41718   {
41719     try {
41720       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
41721     } catch (std::out_of_range& e) {
41722       {
41723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41724       };
41725     } catch (std::exception& e) {
41726       {
41727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41728       };
41729     } catch (...) {
41730       {
41731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41732       };
41733     }
41734   }
41735   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41736   return jresult;
41737 }
41738
41739
41740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
41741   void * jresult ;
41742   Dali::BaseHandle arg1 ;
41743   Dali::BaseHandle *argp1 ;
41744   Dali::EncodedBufferImage result;
41745
41746   argp1 = (Dali::BaseHandle *)jarg1;
41747   if (!argp1) {
41748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41749     return 0;
41750   }
41751   arg1 = *argp1;
41752   {
41753     try {
41754       result = Dali::EncodedBufferImage::DownCast(arg1);
41755     } catch (std::out_of_range& e) {
41756       {
41757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41758       };
41759     } catch (std::exception& e) {
41760       {
41761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41762       };
41763     } catch (...) {
41764       {
41765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41766       };
41767     }
41768   }
41769   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41770   return jresult;
41771 }
41772
41773
41774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
41775   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
41776
41777   arg1 = (Dali::EncodedBufferImage *)jarg1;
41778   {
41779     try {
41780       delete arg1;
41781     } catch (std::out_of_range& e) {
41782       {
41783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41784       };
41785     } catch (std::exception& e) {
41786       {
41787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41788       };
41789     } catch (...) {
41790       {
41791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41792       };
41793     }
41794   }
41795 }
41796
41797
41798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
41799   void * jresult ;
41800   Dali::EncodedBufferImage *arg1 = 0 ;
41801   Dali::EncodedBufferImage *result = 0 ;
41802
41803   arg1 = (Dali::EncodedBufferImage *)jarg1;
41804   if (!arg1) {
41805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
41806     return 0;
41807   }
41808   {
41809     try {
41810       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
41811     } catch (std::out_of_range& e) {
41812       {
41813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41814       };
41815     } catch (std::exception& e) {
41816       {
41817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41818       };
41819     } catch (...) {
41820       {
41821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41822       };
41823     }
41824   }
41825   jresult = (void *)result;
41826   return jresult;
41827 }
41828
41829
41830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
41831   void * jresult ;
41832   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
41833   Dali::EncodedBufferImage *arg2 = 0 ;
41834   Dali::EncodedBufferImage *result = 0 ;
41835
41836   arg1 = (Dali::EncodedBufferImage *)jarg1;
41837   arg2 = (Dali::EncodedBufferImage *)jarg2;
41838   if (!arg2) {
41839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
41840     return 0;
41841   }
41842   {
41843     try {
41844       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
41845     } catch (std::out_of_range& e) {
41846       {
41847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41848       };
41849     } catch (std::exception& e) {
41850       {
41851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41852       };
41853     } catch (...) {
41854       {
41855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41856       };
41857     }
41858   }
41859   jresult = (void *)result;
41860   return jresult;
41861 }
41862
41863
41864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
41865   void * jresult ;
41866   Dali::NativeImage *result = 0 ;
41867
41868   {
41869     try {
41870       result = (Dali::NativeImage *)new Dali::NativeImage();
41871     } catch (std::out_of_range& e) {
41872       {
41873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41874       };
41875     } catch (std::exception& e) {
41876       {
41877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41878       };
41879     } catch (...) {
41880       {
41881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41882       };
41883     }
41884   }
41885   jresult = (void *)result;
41886   return jresult;
41887 }
41888
41889
41890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
41891   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
41892
41893   arg1 = (Dali::NativeImage *)jarg1;
41894   {
41895     try {
41896       delete arg1;
41897     } catch (std::out_of_range& e) {
41898       {
41899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41900       };
41901     } catch (std::exception& e) {
41902       {
41903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41904       };
41905     } catch (...) {
41906       {
41907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41908       };
41909     }
41910   }
41911 }
41912
41913
41914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
41915   void * jresult ;
41916   Dali::NativeImage *arg1 = 0 ;
41917   Dali::NativeImage *result = 0 ;
41918
41919   arg1 = (Dali::NativeImage *)jarg1;
41920   if (!arg1) {
41921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
41922     return 0;
41923   }
41924   {
41925     try {
41926       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
41927     } catch (std::out_of_range& e) {
41928       {
41929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41930       };
41931     } catch (std::exception& e) {
41932       {
41933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41934       };
41935     } catch (...) {
41936       {
41937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41938       };
41939     }
41940   }
41941   jresult = (void *)result;
41942   return jresult;
41943 }
41944
41945
41946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
41947   void * jresult ;
41948   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
41949   Dali::NativeImage *arg2 = 0 ;
41950   Dali::NativeImage *result = 0 ;
41951
41952   arg1 = (Dali::NativeImage *)jarg1;
41953   arg2 = (Dali::NativeImage *)jarg2;
41954   if (!arg2) {
41955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
41956     return 0;
41957   }
41958   {
41959     try {
41960       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
41961     } catch (std::out_of_range& e) {
41962       {
41963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41964       };
41965     } catch (std::exception& e) {
41966       {
41967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41968       };
41969     } catch (...) {
41970       {
41971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41972       };
41973     }
41974   }
41975   jresult = (void *)result;
41976   return jresult;
41977 }
41978
41979
41980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
41981   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
41982
41983   arg1 = (Dali::NativeImage *)jarg1;
41984   {
41985     try {
41986       (arg1)->CreateGlTexture();
41987     } catch (std::out_of_range& e) {
41988       {
41989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41990       };
41991     } catch (std::exception& e) {
41992       {
41993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41994       };
41995     } catch (...) {
41996       {
41997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41998       };
41999     }
42000   }
42001 }
42002
42003
42004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
42005   void * jresult ;
42006   NativeImageInterface *arg1 = 0 ;
42007   Dali::NativeImage result;
42008
42009   arg1 = (NativeImageInterface *)jarg1;
42010   if (!arg1) {
42011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
42012     return 0;
42013   }
42014   {
42015     try {
42016       result = Dali::NativeImage::New(*arg1);
42017     } catch (std::out_of_range& e) {
42018       {
42019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42020       };
42021     } catch (std::exception& e) {
42022       {
42023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42024       };
42025     } catch (...) {
42026       {
42027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42028       };
42029     }
42030   }
42031   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
42032   return jresult;
42033 }
42034
42035
42036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
42037   void * jresult ;
42038   Dali::BaseHandle arg1 ;
42039   Dali::BaseHandle *argp1 ;
42040   Dali::NativeImage result;
42041
42042   argp1 = (Dali::BaseHandle *)jarg1;
42043   if (!argp1) {
42044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42045     return 0;
42046   }
42047   arg1 = *argp1;
42048   {
42049     try {
42050       result = Dali::NativeImage::DownCast(arg1);
42051     } catch (std::out_of_range& e) {
42052       {
42053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42054       };
42055     } catch (std::exception& e) {
42056       {
42057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42058       };
42059     } catch (...) {
42060       {
42061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42062       };
42063     }
42064   }
42065   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
42066   return jresult;
42067 }
42068
42069
42070 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
42071   char * jresult ;
42072   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42073   char *result = 0 ;
42074
42075   arg1 = (Dali::NativeImage *)jarg1;
42076   {
42077     try {
42078       result = (char *)(arg1)->GetCustomFragmentPreFix();
42079     } catch (std::out_of_range& e) {
42080       {
42081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42082       };
42083     } catch (std::exception& e) {
42084       {
42085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42086       };
42087     } catch (...) {
42088       {
42089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42090       };
42091     }
42092   }
42093   jresult = SWIG_csharp_string_callback((const char *)result);
42094   return jresult;
42095 }
42096
42097
42098 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
42099   char * jresult ;
42100   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42101   char *result = 0 ;
42102
42103   arg1 = (Dali::NativeImage *)jarg1;
42104   {
42105     try {
42106       result = (char *)(arg1)->GetCustomSamplerTypename();
42107     } catch (std::out_of_range& e) {
42108       {
42109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42110       };
42111     } catch (std::exception& e) {
42112       {
42113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42114       };
42115     } catch (...) {
42116       {
42117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42118       };
42119     }
42120   }
42121   jresult = SWIG_csharp_string_callback((const char *)result);
42122   return jresult;
42123 }
42124
42125
42126 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
42127   unsigned int jresult ;
42128   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42129   bool result;
42130
42131   arg1 = (Dali::NativeImageInterface *)jarg1;
42132   {
42133     try {
42134       result = (bool)(arg1)->GlExtensionCreate();
42135     } catch (std::out_of_range& e) {
42136       {
42137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42138       };
42139     } catch (std::exception& e) {
42140       {
42141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42142       };
42143     } catch (...) {
42144       {
42145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42146       };
42147     }
42148   }
42149   jresult = result;
42150   return jresult;
42151 }
42152
42153
42154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
42155   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42156
42157   arg1 = (Dali::NativeImageInterface *)jarg1;
42158   {
42159     try {
42160       (arg1)->GlExtensionDestroy();
42161     } catch (std::out_of_range& e) {
42162       {
42163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42164       };
42165     } catch (std::exception& e) {
42166       {
42167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42168       };
42169     } catch (...) {
42170       {
42171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42172       };
42173     }
42174   }
42175 }
42176
42177
42178 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
42179   unsigned int jresult ;
42180   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42181   unsigned int result;
42182
42183   arg1 = (Dali::NativeImageInterface *)jarg1;
42184   {
42185     try {
42186       result = (unsigned int)(arg1)->TargetTexture();
42187     } catch (std::out_of_range& e) {
42188       {
42189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42190       };
42191     } catch (std::exception& e) {
42192       {
42193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42194       };
42195     } catch (...) {
42196       {
42197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42198       };
42199     }
42200   }
42201   jresult = result;
42202   return jresult;
42203 }
42204
42205
42206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
42207   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42208
42209   arg1 = (Dali::NativeImageInterface *)jarg1;
42210   {
42211     try {
42212       (arg1)->PrepareTexture();
42213     } catch (std::out_of_range& e) {
42214       {
42215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42216       };
42217     } catch (std::exception& e) {
42218       {
42219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42220       };
42221     } catch (...) {
42222       {
42223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42224       };
42225     }
42226   }
42227 }
42228
42229
42230 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
42231   unsigned int jresult ;
42232   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42233   unsigned int result;
42234
42235   arg1 = (Dali::NativeImageInterface *)jarg1;
42236   {
42237     try {
42238       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
42239     } catch (std::out_of_range& e) {
42240       {
42241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42242       };
42243     } catch (std::exception& e) {
42244       {
42245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42246       };
42247     } catch (...) {
42248       {
42249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42250       };
42251     }
42252   }
42253   jresult = result;
42254   return jresult;
42255 }
42256
42257
42258 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
42259   unsigned int jresult ;
42260   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42261   unsigned int result;
42262
42263   arg1 = (Dali::NativeImageInterface *)jarg1;
42264   {
42265     try {
42266       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
42267     } catch (std::out_of_range& e) {
42268       {
42269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42270       };
42271     } catch (std::exception& e) {
42272       {
42273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42274       };
42275     } catch (...) {
42276       {
42277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42278       };
42279     }
42280   }
42281   jresult = result;
42282   return jresult;
42283 }
42284
42285
42286 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
42287   unsigned int jresult ;
42288   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42289   bool result;
42290
42291   arg1 = (Dali::NativeImageInterface *)jarg1;
42292   {
42293     try {
42294       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
42295     } catch (std::out_of_range& e) {
42296       {
42297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42298       };
42299     } catch (std::exception& e) {
42300       {
42301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42302       };
42303     } catch (...) {
42304       {
42305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42306       };
42307     }
42308   }
42309   jresult = result;
42310   return jresult;
42311 }
42312
42313
42314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
42315   void * jresult ;
42316   std::string *arg1 = 0 ;
42317   Dali::ImageDimensions result;
42318
42319   if (!jarg1) {
42320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42321     return 0;
42322   }
42323   std::string arg1_str(jarg1);
42324   arg1 = &arg1_str;
42325   {
42326     try {
42327       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
42328     } catch (std::out_of_range& e) {
42329       {
42330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42331       };
42332     } catch (std::exception& e) {
42333       {
42334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42335       };
42336     } catch (...) {
42337       {
42338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42339       };
42340     }
42341   }
42342   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
42343
42344   //argout typemap for const std::string&
42345
42346   return jresult;
42347 }
42348
42349
42350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
42351   void * jresult ;
42352   Dali::ResourceImage *result = 0 ;
42353
42354   {
42355     try {
42356       result = (Dali::ResourceImage *)new Dali::ResourceImage();
42357     } catch (std::out_of_range& e) {
42358       {
42359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42360       };
42361     } catch (std::exception& e) {
42362       {
42363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42364       };
42365     } catch (...) {
42366       {
42367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42368       };
42369     }
42370   }
42371   jresult = (void *)result;
42372   return jresult;
42373 }
42374
42375
42376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
42377   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42378
42379   arg1 = (Dali::ResourceImage *)jarg1;
42380   {
42381     try {
42382       delete arg1;
42383     } catch (std::out_of_range& e) {
42384       {
42385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42386       };
42387     } catch (std::exception& e) {
42388       {
42389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42390       };
42391     } catch (...) {
42392       {
42393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42394       };
42395     }
42396   }
42397 }
42398
42399
42400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
42401   void * jresult ;
42402   Dali::ResourceImage *arg1 = 0 ;
42403   Dali::ResourceImage *result = 0 ;
42404
42405   arg1 = (Dali::ResourceImage *)jarg1;
42406   if (!arg1) {
42407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42408     return 0;
42409   }
42410   {
42411     try {
42412       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
42413     } catch (std::out_of_range& e) {
42414       {
42415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42416       };
42417     } catch (std::exception& e) {
42418       {
42419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42420       };
42421     } catch (...) {
42422       {
42423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42424       };
42425     }
42426   }
42427   jresult = (void *)result;
42428   return jresult;
42429 }
42430
42431
42432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
42433   void * jresult ;
42434   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42435   Dali::ResourceImage *arg2 = 0 ;
42436   Dali::ResourceImage *result = 0 ;
42437
42438   arg1 = (Dali::ResourceImage *)jarg1;
42439   arg2 = (Dali::ResourceImage *)jarg2;
42440   if (!arg2) {
42441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42442     return 0;
42443   }
42444   {
42445     try {
42446       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
42447     } catch (std::out_of_range& e) {
42448       {
42449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42450       };
42451     } catch (std::exception& e) {
42452       {
42453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42454       };
42455     } catch (...) {
42456       {
42457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42458       };
42459     }
42460   }
42461   jresult = (void *)result;
42462   return jresult;
42463 }
42464
42465
42466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
42467   void * jresult ;
42468   std::string *arg1 = 0 ;
42469   bool arg2 ;
42470   Dali::ResourceImage result;
42471
42472   if (!jarg1) {
42473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42474     return 0;
42475   }
42476   std::string arg1_str(jarg1);
42477   arg1 = &arg1_str;
42478   arg2 = jarg2 ? true : false;
42479   {
42480     try {
42481       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42482     } catch (std::out_of_range& e) {
42483       {
42484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42485       };
42486     } catch (std::exception& e) {
42487       {
42488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42489       };
42490     } catch (...) {
42491       {
42492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42493       };
42494     }
42495   }
42496   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42497
42498   //argout typemap for const std::string&
42499
42500   return jresult;
42501 }
42502
42503
42504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
42505   void * jresult ;
42506   std::string *arg1 = 0 ;
42507   Dali::ResourceImage result;
42508
42509   if (!jarg1) {
42510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42511     return 0;
42512   }
42513   std::string arg1_str(jarg1);
42514   arg1 = &arg1_str;
42515   {
42516     try {
42517       result = Dali::ResourceImage::New((std::string const &)*arg1);
42518     } catch (std::out_of_range& e) {
42519       {
42520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42521       };
42522     } catch (std::exception& e) {
42523       {
42524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42525       };
42526     } catch (...) {
42527       {
42528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42529       };
42530     }
42531   }
42532   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42533
42534   //argout typemap for const std::string&
42535
42536   return jresult;
42537 }
42538
42539
42540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
42541   void * jresult ;
42542   std::string *arg1 = 0 ;
42543   Dali::ImageDimensions arg2 ;
42544   Dali::FittingMode::Type arg3 ;
42545   Dali::SamplingMode::Type arg4 ;
42546   bool arg5 ;
42547   Dali::ImageDimensions *argp2 ;
42548   Dali::ResourceImage result;
42549
42550   if (!jarg1) {
42551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42552     return 0;
42553   }
42554   std::string arg1_str(jarg1);
42555   arg1 = &arg1_str;
42556   argp2 = (Dali::ImageDimensions *)jarg2;
42557   if (!argp2) {
42558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42559     return 0;
42560   }
42561   arg2 = *argp2;
42562   arg3 = (Dali::FittingMode::Type)jarg3;
42563   arg4 = (Dali::SamplingMode::Type)jarg4;
42564   arg5 = jarg5 ? true : false;
42565   {
42566     try {
42567       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
42568     } catch (std::out_of_range& e) {
42569       {
42570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42571       };
42572     } catch (std::exception& e) {
42573       {
42574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42575       };
42576     } catch (...) {
42577       {
42578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42579       };
42580     }
42581   }
42582   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42583
42584   //argout typemap for const std::string&
42585
42586   return jresult;
42587 }
42588
42589
42590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
42591   void * jresult ;
42592   std::string *arg1 = 0 ;
42593   Dali::ImageDimensions arg2 ;
42594   Dali::FittingMode::Type arg3 ;
42595   Dali::SamplingMode::Type arg4 ;
42596   Dali::ImageDimensions *argp2 ;
42597   Dali::ResourceImage result;
42598
42599   if (!jarg1) {
42600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42601     return 0;
42602   }
42603   std::string arg1_str(jarg1);
42604   arg1 = &arg1_str;
42605   argp2 = (Dali::ImageDimensions *)jarg2;
42606   if (!argp2) {
42607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42608     return 0;
42609   }
42610   arg2 = *argp2;
42611   arg3 = (Dali::FittingMode::Type)jarg3;
42612   arg4 = (Dali::SamplingMode::Type)jarg4;
42613   {
42614     try {
42615       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
42616     } catch (std::out_of_range& e) {
42617       {
42618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42619       };
42620     } catch (std::exception& e) {
42621       {
42622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42623       };
42624     } catch (...) {
42625       {
42626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42627       };
42628     }
42629   }
42630   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42631
42632   //argout typemap for const std::string&
42633
42634   return jresult;
42635 }
42636
42637
42638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
42639   void * jresult ;
42640   std::string *arg1 = 0 ;
42641   Dali::ImageDimensions arg2 ;
42642   Dali::FittingMode::Type arg3 ;
42643   Dali::ImageDimensions *argp2 ;
42644   Dali::ResourceImage result;
42645
42646   if (!jarg1) {
42647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42648     return 0;
42649   }
42650   std::string arg1_str(jarg1);
42651   arg1 = &arg1_str;
42652   argp2 = (Dali::ImageDimensions *)jarg2;
42653   if (!argp2) {
42654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42655     return 0;
42656   }
42657   arg2 = *argp2;
42658   arg3 = (Dali::FittingMode::Type)jarg3;
42659   {
42660     try {
42661       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
42662     } catch (std::out_of_range& e) {
42663       {
42664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42665       };
42666     } catch (std::exception& e) {
42667       {
42668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42669       };
42670     } catch (...) {
42671       {
42672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42673       };
42674     }
42675   }
42676   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42677
42678   //argout typemap for const std::string&
42679
42680   return jresult;
42681 }
42682
42683
42684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
42685   void * jresult ;
42686   std::string *arg1 = 0 ;
42687   Dali::ImageDimensions arg2 ;
42688   Dali::ImageDimensions *argp2 ;
42689   Dali::ResourceImage result;
42690
42691   if (!jarg1) {
42692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42693     return 0;
42694   }
42695   std::string arg1_str(jarg1);
42696   arg1 = &arg1_str;
42697   argp2 = (Dali::ImageDimensions *)jarg2;
42698   if (!argp2) {
42699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42700     return 0;
42701   }
42702   arg2 = *argp2;
42703   {
42704     try {
42705       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42706     } catch (std::out_of_range& e) {
42707       {
42708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42709       };
42710     } catch (std::exception& e) {
42711       {
42712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42713       };
42714     } catch (...) {
42715       {
42716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42717       };
42718     }
42719   }
42720   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42721
42722   //argout typemap for const std::string&
42723
42724   return jresult;
42725 }
42726
42727
42728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
42729   void * jresult ;
42730   Dali::BaseHandle arg1 ;
42731   Dali::BaseHandle *argp1 ;
42732   Dali::ResourceImage result;
42733
42734   argp1 = (Dali::BaseHandle *)jarg1;
42735   if (!argp1) {
42736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42737     return 0;
42738   }
42739   arg1 = *argp1;
42740   {
42741     try {
42742       result = Dali::ResourceImage::DownCast(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   return jresult;
42759 }
42760
42761
42762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
42763   int jresult ;
42764   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42765   Dali::LoadingState result;
42766
42767   arg1 = (Dali::ResourceImage *)jarg1;
42768   {
42769     try {
42770       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
42771     } catch (std::out_of_range& e) {
42772       {
42773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42774       };
42775     } catch (std::exception& e) {
42776       {
42777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42778       };
42779     } catch (...) {
42780       {
42781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42782       };
42783     }
42784   }
42785   jresult = (int)result;
42786   return jresult;
42787 }
42788
42789
42790 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
42791   char * jresult ;
42792   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42793   std::string result;
42794
42795   arg1 = (Dali::ResourceImage *)jarg1;
42796   {
42797     try {
42798       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
42799     } catch (std::out_of_range& e) {
42800       {
42801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42802       };
42803     } catch (std::exception& e) {
42804       {
42805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42806       };
42807     } catch (...) {
42808       {
42809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42810       };
42811     }
42812   }
42813   jresult = SWIG_csharp_string_callback((&result)->c_str());
42814   return jresult;
42815 }
42816
42817
42818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
42819   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42820
42821   arg1 = (Dali::ResourceImage *)jarg1;
42822   {
42823     try {
42824       (arg1)->Reload();
42825     } catch (std::out_of_range& e) {
42826       {
42827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42828       };
42829     } catch (std::exception& e) {
42830       {
42831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42832       };
42833     } catch (...) {
42834       {
42835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42836       };
42837     }
42838   }
42839 }
42840
42841
42842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
42843   void * jresult ;
42844   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42845   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
42846
42847   arg1 = (Dali::ResourceImage *)jarg1;
42848   {
42849     try {
42850       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
42851     } catch (std::out_of_range& e) {
42852       {
42853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42854       };
42855     } catch (std::exception& e) {
42856       {
42857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42858       };
42859     } catch (...) {
42860       {
42861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42862       };
42863     }
42864   }
42865   jresult = (void *)result;
42866   return jresult;
42867 }
42868
42869
42870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
42871   void * jresult ;
42872   Dali::FrameBufferImage *result = 0 ;
42873
42874   {
42875     try {
42876       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
42877     } catch (std::out_of_range& e) {
42878       {
42879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42880       };
42881     } catch (std::exception& e) {
42882       {
42883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42884       };
42885     } catch (...) {
42886       {
42887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42888       };
42889     }
42890   }
42891   jresult = (void *)result;
42892   return jresult;
42893 }
42894
42895
42896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
42897   void * jresult ;
42898   unsigned int arg1 ;
42899   unsigned int arg2 ;
42900   Dali::Pixel::Format arg3 ;
42901   Dali::RenderBuffer::Format arg4 ;
42902   Dali::FrameBufferImage result;
42903
42904   arg1 = (unsigned int)jarg1;
42905   arg2 = (unsigned int)jarg2;
42906   arg3 = (Dali::Pixel::Format)jarg3;
42907   arg4 = (Dali::RenderBuffer::Format)jarg4;
42908   {
42909     try {
42910       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
42911     } catch (std::out_of_range& e) {
42912       {
42913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42914       };
42915     } catch (std::exception& e) {
42916       {
42917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42918       };
42919     } catch (...) {
42920       {
42921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42922       };
42923     }
42924   }
42925   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42926   return jresult;
42927 }
42928
42929
42930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
42931   void * jresult ;
42932   unsigned int arg1 ;
42933   unsigned int arg2 ;
42934   Dali::Pixel::Format arg3 ;
42935   Dali::FrameBufferImage result;
42936
42937   arg1 = (unsigned int)jarg1;
42938   arg2 = (unsigned int)jarg2;
42939   arg3 = (Dali::Pixel::Format)jarg3;
42940   {
42941     try {
42942       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
42943     } catch (std::out_of_range& e) {
42944       {
42945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42946       };
42947     } catch (std::exception& e) {
42948       {
42949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42950       };
42951     } catch (...) {
42952       {
42953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42954       };
42955     }
42956   }
42957   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42958   return jresult;
42959 }
42960
42961
42962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
42963   void * jresult ;
42964   unsigned int arg1 ;
42965   unsigned int arg2 ;
42966   Dali::FrameBufferImage result;
42967
42968   arg1 = (unsigned int)jarg1;
42969   arg2 = (unsigned int)jarg2;
42970   {
42971     try {
42972       result = Dali::FrameBufferImage::New(arg1,arg2);
42973     } catch (std::out_of_range& e) {
42974       {
42975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42976       };
42977     } catch (std::exception& e) {
42978       {
42979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42980       };
42981     } catch (...) {
42982       {
42983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42984       };
42985     }
42986   }
42987   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42988   return jresult;
42989 }
42990
42991
42992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
42993   void * jresult ;
42994   unsigned int arg1 ;
42995   Dali::FrameBufferImage result;
42996
42997   arg1 = (unsigned int)jarg1;
42998   {
42999     try {
43000       result = Dali::FrameBufferImage::New(arg1);
43001     } catch (std::out_of_range& e) {
43002       {
43003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43004       };
43005     } catch (std::exception& e) {
43006       {
43007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43008       };
43009     } catch (...) {
43010       {
43011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43012       };
43013     }
43014   }
43015   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43016   return jresult;
43017 }
43018
43019
43020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
43021   void * jresult ;
43022   Dali::FrameBufferImage result;
43023
43024   {
43025     try {
43026       result = Dali::FrameBufferImage::New();
43027     } catch (std::out_of_range& e) {
43028       {
43029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43030       };
43031     } catch (std::exception& e) {
43032       {
43033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43034       };
43035     } catch (...) {
43036       {
43037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43038       };
43039     }
43040   }
43041   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43042   return jresult;
43043 }
43044
43045
43046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
43047   void * jresult ;
43048   Dali::NativeImageInterface *arg1 = 0 ;
43049   Dali::FrameBufferImage result;
43050
43051   arg1 = (Dali::NativeImageInterface *)jarg1;
43052   if (!arg1) {
43053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
43054     return 0;
43055   }
43056   {
43057     try {
43058       result = Dali::FrameBufferImage::New(*arg1);
43059     } catch (std::out_of_range& e) {
43060       {
43061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43062       };
43063     } catch (std::exception& e) {
43064       {
43065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43066       };
43067     } catch (...) {
43068       {
43069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43070       };
43071     }
43072   }
43073   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43074   return jresult;
43075 }
43076
43077
43078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
43079   void * jresult ;
43080   Dali::BaseHandle arg1 ;
43081   Dali::BaseHandle *argp1 ;
43082   Dali::FrameBufferImage result;
43083
43084   argp1 = (Dali::BaseHandle *)jarg1;
43085   if (!argp1) {
43086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43087     return 0;
43088   }
43089   arg1 = *argp1;
43090   {
43091     try {
43092       result = Dali::FrameBufferImage::DownCast(arg1);
43093     } catch (std::out_of_range& e) {
43094       {
43095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43096       };
43097     } catch (std::exception& e) {
43098       {
43099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43100       };
43101     } catch (...) {
43102       {
43103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43104       };
43105     }
43106   }
43107   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43108   return jresult;
43109 }
43110
43111
43112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
43113   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
43114
43115   arg1 = (Dali::FrameBufferImage *)jarg1;
43116   {
43117     try {
43118       delete arg1;
43119     } catch (std::out_of_range& e) {
43120       {
43121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43122       };
43123     } catch (std::exception& e) {
43124       {
43125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43126       };
43127     } catch (...) {
43128       {
43129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43130       };
43131     }
43132   }
43133 }
43134
43135
43136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
43137   void * jresult ;
43138   Dali::FrameBufferImage *arg1 = 0 ;
43139   Dali::FrameBufferImage *result = 0 ;
43140
43141   arg1 = (Dali::FrameBufferImage *)jarg1;
43142   if (!arg1) {
43143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
43144     return 0;
43145   }
43146   {
43147     try {
43148       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
43149     } catch (std::out_of_range& e) {
43150       {
43151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43152       };
43153     } catch (std::exception& e) {
43154       {
43155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43156       };
43157     } catch (...) {
43158       {
43159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43160       };
43161     }
43162   }
43163   jresult = (void *)result;
43164   return jresult;
43165 }
43166
43167
43168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
43169   void * jresult ;
43170   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
43171   Dali::FrameBufferImage *arg2 = 0 ;
43172   Dali::FrameBufferImage *result = 0 ;
43173
43174   arg1 = (Dali::FrameBufferImage *)jarg1;
43175   arg2 = (Dali::FrameBufferImage *)jarg2;
43176   if (!arg2) {
43177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
43178     return 0;
43179   }
43180   {
43181     try {
43182       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
43183     } catch (std::out_of_range& e) {
43184       {
43185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43186       };
43187     } catch (std::exception& e) {
43188       {
43189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43190       };
43191     } catch (...) {
43192       {
43193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43194       };
43195     }
43196   }
43197   jresult = (void *)result;
43198   return jresult;
43199 }
43200
43201
43202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
43203   void * jresult ;
43204   Dali::NinePatchImage *result = 0 ;
43205
43206   {
43207     try {
43208       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
43209     } catch (std::out_of_range& e) {
43210       {
43211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43212       };
43213     } catch (std::exception& e) {
43214       {
43215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43216       };
43217     } catch (...) {
43218       {
43219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43220       };
43221     }
43222   }
43223   jresult = (void *)result;
43224   return jresult;
43225 }
43226
43227
43228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
43229   void * jresult ;
43230   std::string *arg1 = 0 ;
43231   Dali::NinePatchImage result;
43232
43233   if (!jarg1) {
43234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43235     return 0;
43236   }
43237   std::string arg1_str(jarg1);
43238   arg1 = &arg1_str;
43239   {
43240     try {
43241       result = Dali::NinePatchImage::New((std::string const &)*arg1);
43242     } catch (std::out_of_range& e) {
43243       {
43244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43245       };
43246     } catch (std::exception& e) {
43247       {
43248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43249       };
43250     } catch (...) {
43251       {
43252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43253       };
43254     }
43255   }
43256   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43257
43258   //argout typemap for const std::string&
43259
43260   return jresult;
43261 }
43262
43263
43264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
43265   void * jresult ;
43266   Dali::BaseHandle arg1 ;
43267   Dali::BaseHandle *argp1 ;
43268   Dali::NinePatchImage result;
43269
43270   argp1 = (Dali::BaseHandle *)jarg1;
43271   if (!argp1) {
43272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43273     return 0;
43274   }
43275   arg1 = *argp1;
43276   {
43277     try {
43278       result = Dali::NinePatchImage::DownCast(arg1);
43279     } catch (std::out_of_range& e) {
43280       {
43281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43282       };
43283     } catch (std::exception& e) {
43284       {
43285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43286       };
43287     } catch (...) {
43288       {
43289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43290       };
43291     }
43292   }
43293   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43294   return jresult;
43295 }
43296
43297
43298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
43299   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43300
43301   arg1 = (Dali::NinePatchImage *)jarg1;
43302   {
43303     try {
43304       delete arg1;
43305     } catch (std::out_of_range& e) {
43306       {
43307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43308       };
43309     } catch (std::exception& e) {
43310       {
43311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43312       };
43313     } catch (...) {
43314       {
43315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43316       };
43317     }
43318   }
43319 }
43320
43321
43322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
43323   void * jresult ;
43324   Dali::NinePatchImage *arg1 = 0 ;
43325   Dali::NinePatchImage *result = 0 ;
43326
43327   arg1 = (Dali::NinePatchImage *)jarg1;
43328   if (!arg1) {
43329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43330     return 0;
43331   }
43332   {
43333     try {
43334       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
43335     } catch (std::out_of_range& e) {
43336       {
43337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43338       };
43339     } catch (std::exception& e) {
43340       {
43341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43342       };
43343     } catch (...) {
43344       {
43345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43346       };
43347     }
43348   }
43349   jresult = (void *)result;
43350   return jresult;
43351 }
43352
43353
43354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
43355   void * jresult ;
43356   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43357   Dali::NinePatchImage *arg2 = 0 ;
43358   Dali::NinePatchImage *result = 0 ;
43359
43360   arg1 = (Dali::NinePatchImage *)jarg1;
43361   arg2 = (Dali::NinePatchImage *)jarg2;
43362   if (!arg2) {
43363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43364     return 0;
43365   }
43366   {
43367     try {
43368       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
43369     } catch (std::out_of_range& e) {
43370       {
43371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43372       };
43373     } catch (std::exception& e) {
43374       {
43375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43376       };
43377     } catch (...) {
43378       {
43379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43380       };
43381     }
43382   }
43383   jresult = (void *)result;
43384   return jresult;
43385 }
43386
43387
43388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
43389   void * jresult ;
43390   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43391   Dali::Vector4 result;
43392
43393   arg1 = (Dali::NinePatchImage *)jarg1;
43394   {
43395     try {
43396       result = (arg1)->GetStretchBorders();
43397     } catch (std::out_of_range& e) {
43398       {
43399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43400       };
43401     } catch (std::exception& e) {
43402       {
43403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43404       };
43405     } catch (...) {
43406       {
43407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43408       };
43409     }
43410   }
43411   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43412   return jresult;
43413 }
43414
43415
43416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
43417   void * jresult ;
43418   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43419   Dali::NinePatchImage::StretchRanges *result = 0 ;
43420
43421   arg1 = (Dali::NinePatchImage *)jarg1;
43422   {
43423     try {
43424       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
43425     } catch (std::out_of_range& e) {
43426       {
43427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43428       };
43429     } catch (std::exception& e) {
43430       {
43431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43432       };
43433     } catch (...) {
43434       {
43435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43436       };
43437     }
43438   }
43439   jresult = (void *)result;
43440   return jresult;
43441 }
43442
43443
43444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
43445   void * jresult ;
43446   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43447   Dali::NinePatchImage::StretchRanges *result = 0 ;
43448
43449   arg1 = (Dali::NinePatchImage *)jarg1;
43450   {
43451     try {
43452       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
43453     } catch (std::out_of_range& e) {
43454       {
43455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43456       };
43457     } catch (std::exception& e) {
43458       {
43459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43460       };
43461     } catch (...) {
43462       {
43463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43464       };
43465     }
43466   }
43467   jresult = (void *)result;
43468   return jresult;
43469 }
43470
43471
43472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
43473   void * jresult ;
43474   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43475   Dali::Rect< int > result;
43476
43477   arg1 = (Dali::NinePatchImage *)jarg1;
43478   {
43479     try {
43480       result = (arg1)->GetChildRectangle();
43481     } catch (std::out_of_range& e) {
43482       {
43483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43484       };
43485     } catch (std::exception& e) {
43486       {
43487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43488       };
43489     } catch (...) {
43490       {
43491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43492       };
43493     }
43494   }
43495   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
43496   return jresult;
43497 }
43498
43499
43500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
43501   void * jresult ;
43502   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43503   Dali::BufferImage result;
43504
43505   arg1 = (Dali::NinePatchImage *)jarg1;
43506   {
43507     try {
43508       result = (arg1)->CreateCroppedBufferImage();
43509     } catch (std::out_of_range& e) {
43510       {
43511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43512       };
43513     } catch (std::exception& e) {
43514       {
43515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43516       };
43517     } catch (...) {
43518       {
43519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43520       };
43521     }
43522   }
43523   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
43524   return jresult;
43525 }
43526
43527
43528 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
43529   unsigned int jresult ;
43530   std::string *arg1 = 0 ;
43531   bool result;
43532
43533   if (!jarg1) {
43534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43535     return 0;
43536   }
43537   std::string arg1_str(jarg1);
43538   arg1 = &arg1_str;
43539   {
43540     try {
43541       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
43542     } catch (std::out_of_range& e) {
43543       {
43544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43545       };
43546     } catch (std::exception& e) {
43547       {
43548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43549       };
43550     } catch (...) {
43551       {
43552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43553       };
43554     }
43555   }
43556   jresult = result;
43557
43558   //argout typemap for const std::string&
43559
43560   return jresult;
43561 }
43562
43563
43564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
43565   int jresult ;
43566   int result;
43567
43568   result = (int)Dali::CameraActor::Property::TYPE;
43569   jresult = (int)result;
43570   return jresult;
43571 }
43572
43573
43574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
43575   int jresult ;
43576   int result;
43577
43578   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
43579   jresult = (int)result;
43580   return jresult;
43581 }
43582
43583
43584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
43585   int jresult ;
43586   int result;
43587
43588   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
43589   jresult = (int)result;
43590   return jresult;
43591 }
43592
43593
43594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
43595   int jresult ;
43596   int result;
43597
43598   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
43599   jresult = (int)result;
43600   return jresult;
43601 }
43602
43603
43604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
43605   int jresult ;
43606   int result;
43607
43608   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
43609   jresult = (int)result;
43610   return jresult;
43611 }
43612
43613
43614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
43615   int jresult ;
43616   int result;
43617
43618   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
43619   jresult = (int)result;
43620   return jresult;
43621 }
43622
43623
43624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
43625   int jresult ;
43626   int result;
43627
43628   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
43629   jresult = (int)result;
43630   return jresult;
43631 }
43632
43633
43634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
43635   int jresult ;
43636   int result;
43637
43638   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
43639   jresult = (int)result;
43640   return jresult;
43641 }
43642
43643
43644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
43645   int jresult ;
43646   int result;
43647
43648   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
43649   jresult = (int)result;
43650   return jresult;
43651 }
43652
43653
43654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
43655   int jresult ;
43656   int result;
43657
43658   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
43659   jresult = (int)result;
43660   return jresult;
43661 }
43662
43663
43664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
43665   int jresult ;
43666   int result;
43667
43668   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
43669   jresult = (int)result;
43670   return jresult;
43671 }
43672
43673
43674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
43675   int jresult ;
43676   int result;
43677
43678   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
43679   jresult = (int)result;
43680   return jresult;
43681 }
43682
43683
43684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
43685   int jresult ;
43686   int result;
43687
43688   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
43689   jresult = (int)result;
43690   return jresult;
43691 }
43692
43693
43694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
43695   int jresult ;
43696   int result;
43697
43698   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
43699   jresult = (int)result;
43700   return jresult;
43701 }
43702
43703
43704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
43705   void * jresult ;
43706   Dali::CameraActor::Property *result = 0 ;
43707
43708   {
43709     try {
43710       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
43711     } catch (std::out_of_range& e) {
43712       {
43713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43714       };
43715     } catch (std::exception& e) {
43716       {
43717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43718       };
43719     } catch (...) {
43720       {
43721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43722       };
43723     }
43724   }
43725   jresult = (void *)result;
43726   return jresult;
43727 }
43728
43729
43730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
43731   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
43732
43733   arg1 = (Dali::CameraActor::Property *)jarg1;
43734   {
43735     try {
43736       delete arg1;
43737     } catch (std::out_of_range& e) {
43738       {
43739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43740       };
43741     } catch (std::exception& e) {
43742       {
43743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43744       };
43745     } catch (...) {
43746       {
43747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43748       };
43749     }
43750   }
43751 }
43752
43753
43754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
43755   void * jresult ;
43756   Dali::CameraActor *result = 0 ;
43757
43758   {
43759     try {
43760       result = (Dali::CameraActor *)new Dali::CameraActor();
43761     } catch (std::out_of_range& e) {
43762       {
43763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43764       };
43765     } catch (std::exception& e) {
43766       {
43767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43768       };
43769     } catch (...) {
43770       {
43771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43772       };
43773     }
43774   }
43775   jresult = (void *)result;
43776   return jresult;
43777 }
43778
43779
43780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
43781   void * jresult ;
43782   Dali::CameraActor result;
43783
43784   {
43785     try {
43786       result = Dali::CameraActor::New();
43787     } catch (std::out_of_range& e) {
43788       {
43789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43790       };
43791     } catch (std::exception& e) {
43792       {
43793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43794       };
43795     } catch (...) {
43796       {
43797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43798       };
43799     }
43800   }
43801   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
43802   return jresult;
43803 }
43804
43805
43806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
43807   void * jresult ;
43808   Dali::Size *arg1 = 0 ;
43809   Dali::CameraActor result;
43810
43811   arg1 = (Dali::Size *)jarg1;
43812   if (!arg1) {
43813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
43814     return 0;
43815   }
43816   {
43817     try {
43818       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
43819     } catch (std::out_of_range& e) {
43820       {
43821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43822       };
43823     } catch (std::exception& e) {
43824       {
43825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43826       };
43827     } catch (...) {
43828       {
43829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43830       };
43831     }
43832   }
43833   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
43834   return jresult;
43835 }
43836
43837
43838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
43839   void * jresult ;
43840   Dali::BaseHandle arg1 ;
43841   Dali::BaseHandle *argp1 ;
43842   Dali::CameraActor result;
43843
43844   argp1 = (Dali::BaseHandle *)jarg1;
43845   if (!argp1) {
43846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43847     return 0;
43848   }
43849   arg1 = *argp1;
43850   {
43851     try {
43852       result = Dali::CameraActor::DownCast(arg1);
43853     } catch (std::out_of_range& e) {
43854       {
43855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43856       };
43857     } catch (std::exception& e) {
43858       {
43859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43860       };
43861     } catch (...) {
43862       {
43863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43864       };
43865     }
43866   }
43867   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
43868   return jresult;
43869 }
43870
43871
43872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
43873   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43874
43875   arg1 = (Dali::CameraActor *)jarg1;
43876   {
43877     try {
43878       delete arg1;
43879     } catch (std::out_of_range& e) {
43880       {
43881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43882       };
43883     } catch (std::exception& e) {
43884       {
43885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43886       };
43887     } catch (...) {
43888       {
43889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43890       };
43891     }
43892   }
43893 }
43894
43895
43896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
43897   void * jresult ;
43898   Dali::CameraActor *arg1 = 0 ;
43899   Dali::CameraActor *result = 0 ;
43900
43901   arg1 = (Dali::CameraActor *)jarg1;
43902   if (!arg1) {
43903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
43904     return 0;
43905   }
43906   {
43907     try {
43908       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
43909     } catch (std::out_of_range& e) {
43910       {
43911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43912       };
43913     } catch (std::exception& e) {
43914       {
43915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43916       };
43917     } catch (...) {
43918       {
43919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43920       };
43921     }
43922   }
43923   jresult = (void *)result;
43924   return jresult;
43925 }
43926
43927
43928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
43929   void * jresult ;
43930   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43931   Dali::CameraActor *arg2 = 0 ;
43932   Dali::CameraActor *result = 0 ;
43933
43934   arg1 = (Dali::CameraActor *)jarg1;
43935   arg2 = (Dali::CameraActor *)jarg2;
43936   if (!arg2) {
43937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
43938     return 0;
43939   }
43940   {
43941     try {
43942       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
43943     } catch (std::out_of_range& e) {
43944       {
43945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43946       };
43947     } catch (std::exception& e) {
43948       {
43949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43950       };
43951     } catch (...) {
43952       {
43953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43954       };
43955     }
43956   }
43957   jresult = (void *)result;
43958   return jresult;
43959 }
43960
43961
43962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
43963   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43964   Dali::Camera::Type arg2 ;
43965
43966   arg1 = (Dali::CameraActor *)jarg1;
43967   arg2 = (Dali::Camera::Type)jarg2;
43968   {
43969     try {
43970       (arg1)->SetType(arg2);
43971     } catch (std::out_of_range& e) {
43972       {
43973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43974       };
43975     } catch (std::exception& e) {
43976       {
43977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43978       };
43979     } catch (...) {
43980       {
43981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43982       };
43983     }
43984   }
43985 }
43986
43987
43988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
43989   int jresult ;
43990   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43991   Dali::Camera::Type result;
43992
43993   arg1 = (Dali::CameraActor *)jarg1;
43994   {
43995     try {
43996       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
43997     } catch (std::out_of_range& e) {
43998       {
43999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44000       };
44001     } catch (std::exception& e) {
44002       {
44003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44004       };
44005     } catch (...) {
44006       {
44007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44008       };
44009     }
44010   }
44011   jresult = (int)result;
44012   return jresult;
44013 }
44014
44015
44016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
44017   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44018   Dali::Camera::ProjectionMode arg2 ;
44019
44020   arg1 = (Dali::CameraActor *)jarg1;
44021   arg2 = (Dali::Camera::ProjectionMode)jarg2;
44022   {
44023     try {
44024       (arg1)->SetProjectionMode(arg2);
44025     } catch (std::out_of_range& e) {
44026       {
44027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44028       };
44029     } catch (std::exception& e) {
44030       {
44031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44032       };
44033     } catch (...) {
44034       {
44035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44036       };
44037     }
44038   }
44039 }
44040
44041
44042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
44043   int jresult ;
44044   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44045   Dali::Camera::ProjectionMode result;
44046
44047   arg1 = (Dali::CameraActor *)jarg1;
44048   {
44049     try {
44050       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
44051     } catch (std::out_of_range& e) {
44052       {
44053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44054       };
44055     } catch (std::exception& e) {
44056       {
44057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44058       };
44059     } catch (...) {
44060       {
44061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44062       };
44063     }
44064   }
44065   jresult = (int)result;
44066   return jresult;
44067 }
44068
44069
44070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
44071   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44072   float arg2 ;
44073
44074   arg1 = (Dali::CameraActor *)jarg1;
44075   arg2 = (float)jarg2;
44076   {
44077     try {
44078       (arg1)->SetFieldOfView(arg2);
44079     } catch (std::out_of_range& e) {
44080       {
44081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44082       };
44083     } catch (std::exception& e) {
44084       {
44085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44086       };
44087     } catch (...) {
44088       {
44089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44090       };
44091     }
44092   }
44093 }
44094
44095
44096 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
44097   float jresult ;
44098   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44099   float result;
44100
44101   arg1 = (Dali::CameraActor *)jarg1;
44102   {
44103     try {
44104       result = (float)(arg1)->GetFieldOfView();
44105     } catch (std::out_of_range& e) {
44106       {
44107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44108       };
44109     } catch (std::exception& e) {
44110       {
44111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44112       };
44113     } catch (...) {
44114       {
44115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44116       };
44117     }
44118   }
44119   jresult = result;
44120   return jresult;
44121 }
44122
44123
44124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
44125   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44126   float arg2 ;
44127
44128   arg1 = (Dali::CameraActor *)jarg1;
44129   arg2 = (float)jarg2;
44130   {
44131     try {
44132       (arg1)->SetAspectRatio(arg2);
44133     } catch (std::out_of_range& e) {
44134       {
44135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44136       };
44137     } catch (std::exception& e) {
44138       {
44139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44140       };
44141     } catch (...) {
44142       {
44143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44144       };
44145     }
44146   }
44147 }
44148
44149
44150 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
44151   float jresult ;
44152   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44153   float result;
44154
44155   arg1 = (Dali::CameraActor *)jarg1;
44156   {
44157     try {
44158       result = (float)(arg1)->GetAspectRatio();
44159     } catch (std::out_of_range& e) {
44160       {
44161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44162       };
44163     } catch (std::exception& e) {
44164       {
44165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44166       };
44167     } catch (...) {
44168       {
44169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44170       };
44171     }
44172   }
44173   jresult = result;
44174   return jresult;
44175 }
44176
44177
44178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
44179   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44180   float arg2 ;
44181
44182   arg1 = (Dali::CameraActor *)jarg1;
44183   arg2 = (float)jarg2;
44184   {
44185     try {
44186       (arg1)->SetNearClippingPlane(arg2);
44187     } catch (std::out_of_range& e) {
44188       {
44189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44190       };
44191     } catch (std::exception& e) {
44192       {
44193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44194       };
44195     } catch (...) {
44196       {
44197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44198       };
44199     }
44200   }
44201 }
44202
44203
44204 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
44205   float jresult ;
44206   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44207   float result;
44208
44209   arg1 = (Dali::CameraActor *)jarg1;
44210   {
44211     try {
44212       result = (float)(arg1)->GetNearClippingPlane();
44213     } catch (std::out_of_range& e) {
44214       {
44215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44216       };
44217     } catch (std::exception& e) {
44218       {
44219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44220       };
44221     } catch (...) {
44222       {
44223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44224       };
44225     }
44226   }
44227   jresult = result;
44228   return jresult;
44229 }
44230
44231
44232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
44233   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44234   float arg2 ;
44235
44236   arg1 = (Dali::CameraActor *)jarg1;
44237   arg2 = (float)jarg2;
44238   {
44239     try {
44240       (arg1)->SetFarClippingPlane(arg2);
44241     } catch (std::out_of_range& e) {
44242       {
44243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44244       };
44245     } catch (std::exception& e) {
44246       {
44247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44248       };
44249     } catch (...) {
44250       {
44251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44252       };
44253     }
44254   }
44255 }
44256
44257
44258 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
44259   float jresult ;
44260   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44261   float result;
44262
44263   arg1 = (Dali::CameraActor *)jarg1;
44264   {
44265     try {
44266       result = (float)(arg1)->GetFarClippingPlane();
44267     } catch (std::out_of_range& e) {
44268       {
44269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44270       };
44271     } catch (std::exception& e) {
44272       {
44273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44274       };
44275     } catch (...) {
44276       {
44277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44278       };
44279     }
44280   }
44281   jresult = result;
44282   return jresult;
44283 }
44284
44285
44286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
44287   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44288   Dali::Vector3 *arg2 = 0 ;
44289
44290   arg1 = (Dali::CameraActor *)jarg1;
44291   arg2 = (Dali::Vector3 *)jarg2;
44292   if (!arg2) {
44293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
44294     return ;
44295   }
44296   {
44297     try {
44298       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
44299     } catch (std::out_of_range& e) {
44300       {
44301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44302       };
44303     } catch (std::exception& e) {
44304       {
44305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44306       };
44307     } catch (...) {
44308       {
44309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44310       };
44311     }
44312   }
44313 }
44314
44315
44316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
44317   void * jresult ;
44318   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44319   Dali::Vector3 result;
44320
44321   arg1 = (Dali::CameraActor *)jarg1;
44322   {
44323     try {
44324       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
44325     } catch (std::out_of_range& e) {
44326       {
44327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44328       };
44329     } catch (std::exception& e) {
44330       {
44331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44332       };
44333     } catch (...) {
44334       {
44335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44336       };
44337     }
44338   }
44339   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
44340   return jresult;
44341 }
44342
44343
44344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
44345   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44346   bool arg2 ;
44347
44348   arg1 = (Dali::CameraActor *)jarg1;
44349   arg2 = jarg2 ? true : false;
44350   {
44351     try {
44352       (arg1)->SetInvertYAxis(arg2);
44353     } catch (std::out_of_range& e) {
44354       {
44355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44356       };
44357     } catch (std::exception& e) {
44358       {
44359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44360       };
44361     } catch (...) {
44362       {
44363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44364       };
44365     }
44366   }
44367 }
44368
44369
44370 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
44371   unsigned int jresult ;
44372   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44373   bool result;
44374
44375   arg1 = (Dali::CameraActor *)jarg1;
44376   {
44377     try {
44378       result = (bool)(arg1)->GetInvertYAxis();
44379     } catch (std::out_of_range& e) {
44380       {
44381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44382       };
44383     } catch (std::exception& e) {
44384       {
44385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44386       };
44387     } catch (...) {
44388       {
44389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44390       };
44391     }
44392   }
44393   jresult = result;
44394   return jresult;
44395 }
44396
44397
44398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
44399   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44400   Dali::Size *arg2 = 0 ;
44401
44402   arg1 = (Dali::CameraActor *)jarg1;
44403   arg2 = (Dali::Size *)jarg2;
44404   if (!arg2) {
44405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44406     return ;
44407   }
44408   {
44409     try {
44410       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
44411     } catch (std::out_of_range& e) {
44412       {
44413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44414       };
44415     } catch (std::exception& e) {
44416       {
44417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44418       };
44419     } catch (...) {
44420       {
44421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44422       };
44423     }
44424   }
44425 }
44426
44427
44428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
44429   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44430   Dali::Size *arg2 = 0 ;
44431
44432   arg1 = (Dali::CameraActor *)jarg1;
44433   arg2 = (Dali::Size *)jarg2;
44434   if (!arg2) {
44435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44436     return ;
44437   }
44438   {
44439     try {
44440       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
44441     } catch (std::out_of_range& e) {
44442       {
44443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44444       };
44445     } catch (std::exception& e) {
44446       {
44447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44448       };
44449     } catch (...) {
44450       {
44451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44452       };
44453     }
44454   }
44455 }
44456
44457
44458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
44459   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44460   float arg2 ;
44461   float arg3 ;
44462   float arg4 ;
44463   float arg5 ;
44464   float arg6 ;
44465   float arg7 ;
44466
44467   arg1 = (Dali::CameraActor *)jarg1;
44468   arg2 = (float)jarg2;
44469   arg3 = (float)jarg3;
44470   arg4 = (float)jarg4;
44471   arg5 = (float)jarg5;
44472   arg6 = (float)jarg6;
44473   arg7 = (float)jarg7;
44474   {
44475     try {
44476       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
44477     } catch (std::out_of_range& e) {
44478       {
44479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44480       };
44481     } catch (std::exception& e) {
44482       {
44483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44484       };
44485     } catch (...) {
44486       {
44487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44488       };
44489     }
44490   }
44491 }
44492
44493
44494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
44495   void * jresult ;
44496   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44497
44498   {
44499     try {
44500       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
44501     } catch (std::out_of_range& e) {
44502       {
44503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44504       };
44505     } catch (std::exception& e) {
44506       {
44507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44508       };
44509     } catch (...) {
44510       {
44511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44512       };
44513     }
44514   }
44515   jresult = (void *)result;
44516   return jresult;
44517 }
44518
44519
44520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
44521   void * jresult ;
44522   std::string arg1 ;
44523   Dali::Property::Value arg2 ;
44524   Dali::Property::Value *argp2 ;
44525   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44526
44527   if (!jarg1) {
44528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44529     return 0;
44530   }
44531   (&arg1)->assign(jarg1);
44532   argp2 = (Dali::Property::Value *)jarg2;
44533   if (!argp2) {
44534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
44535     return 0;
44536   }
44537   arg2 = *argp2;
44538   {
44539     try {
44540       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
44541     } catch (std::out_of_range& e) {
44542       {
44543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44544       };
44545     } catch (std::exception& e) {
44546       {
44547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44548       };
44549     } catch (...) {
44550       {
44551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44552       };
44553     }
44554   }
44555   jresult = (void *)result;
44556   return jresult;
44557 }
44558
44559
44560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
44561   void * jresult ;
44562   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
44563   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44564
44565   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44566   if (!arg1) {
44567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
44568     return 0;
44569   }
44570   {
44571     try {
44572       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);
44573     } catch (std::out_of_range& e) {
44574       {
44575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44576       };
44577     } catch (std::exception& e) {
44578       {
44579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44580       };
44581     } catch (...) {
44582       {
44583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44584       };
44585     }
44586   }
44587   jresult = (void *)result;
44588   return jresult;
44589 }
44590
44591
44592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
44593   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44594   std::string *arg2 = 0 ;
44595
44596   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44597   if (!jarg2) {
44598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44599     return ;
44600   }
44601   std::string arg2_str(jarg2);
44602   arg2 = &arg2_str;
44603   if (arg1) (arg1)->first = *arg2;
44604
44605   //argout typemap for const std::string&
44606
44607 }
44608
44609
44610 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
44611   char * jresult ;
44612   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44613   std::string *result = 0 ;
44614
44615   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44616   result = (std::string *) & ((arg1)->first);
44617   jresult = SWIG_csharp_string_callback(result->c_str());
44618   return jresult;
44619 }
44620
44621
44622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
44623   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44624   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
44625
44626   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44627   arg2 = (Dali::Property::Value *)jarg2;
44628   if (arg1) (arg1)->second = *arg2;
44629 }
44630
44631
44632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
44633   void * jresult ;
44634   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44635   Dali::Property::Value *result = 0 ;
44636
44637   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44638   result = (Dali::Property::Value *)& ((arg1)->second);
44639   jresult = (void *)result;
44640   return jresult;
44641 }
44642
44643
44644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
44645   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44646
44647   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44648   {
44649     try {
44650       delete arg1;
44651     } catch (std::out_of_range& e) {
44652       {
44653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44654       };
44655     } catch (std::exception& e) {
44656       {
44657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44658       };
44659     } catch (...) {
44660       {
44661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44662       };
44663     }
44664   }
44665 }
44666
44667
44668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
44669   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44670
44671   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44672   {
44673     try {
44674       (arg1)->clear();
44675     } catch (std::out_of_range& e) {
44676       {
44677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44678       };
44679     } catch (std::exception& e) {
44680       {
44681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44682       };
44683     } catch (...) {
44684       {
44685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44686       };
44687     }
44688   }
44689 }
44690
44691
44692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
44693   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44694   Dali::TouchPoint *arg2 = 0 ;
44695
44696   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44697   arg2 = (Dali::TouchPoint *)jarg2;
44698   if (!arg2) {
44699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
44700     return ;
44701   }
44702   {
44703     try {
44704       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
44705     } catch (std::out_of_range& e) {
44706       {
44707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44708       };
44709     } catch (std::exception& e) {
44710       {
44711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44712       };
44713     } catch (...) {
44714       {
44715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44716       };
44717     }
44718   }
44719 }
44720
44721
44722 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
44723   unsigned long jresult ;
44724   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44725   std::vector< Dali::TouchPoint >::size_type result;
44726
44727   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44728   {
44729     try {
44730       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
44731     } catch (std::out_of_range& e) {
44732       {
44733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44734       };
44735     } catch (std::exception& e) {
44736       {
44737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44738       };
44739     } catch (...) {
44740       {
44741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44742       };
44743     }
44744   }
44745   jresult = (unsigned long)result;
44746   return jresult;
44747 }
44748
44749
44750 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
44751   unsigned long jresult ;
44752   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44753   std::vector< Dali::TouchPoint >::size_type result;
44754
44755   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44756   {
44757     try {
44758       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
44759     } catch (std::out_of_range& e) {
44760       {
44761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44762       };
44763     } catch (std::exception& e) {
44764       {
44765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44766       };
44767     } catch (...) {
44768       {
44769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44770       };
44771     }
44772   }
44773   jresult = (unsigned long)result;
44774   return jresult;
44775 }
44776
44777
44778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
44779   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44780   std::vector< Dali::TouchPoint >::size_type arg2 ;
44781
44782   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44783   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
44784   {
44785     try {
44786       (arg1)->reserve(arg2);
44787     } catch (std::out_of_range& e) {
44788       {
44789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44790       };
44791     } catch (std::exception& e) {
44792       {
44793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44794       };
44795     } catch (...) {
44796       {
44797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44798       };
44799     }
44800   }
44801 }
44802
44803
44804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
44805   void * jresult ;
44806   std::vector< Dali::TouchPoint > *result = 0 ;
44807
44808   {
44809     try {
44810       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
44811     } catch (std::out_of_range& e) {
44812       {
44813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44814       };
44815     } catch (std::exception& e) {
44816       {
44817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44818       };
44819     } catch (...) {
44820       {
44821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44822       };
44823     }
44824   }
44825   jresult = (void *)result;
44826   return jresult;
44827 }
44828
44829
44830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
44831   void * jresult ;
44832   std::vector< Dali::TouchPoint > *arg1 = 0 ;
44833   std::vector< Dali::TouchPoint > *result = 0 ;
44834
44835   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44836   if (!arg1) {
44837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
44838     return 0;
44839   }
44840   {
44841     try {
44842       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
44843     } catch (std::out_of_range& e) {
44844       {
44845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44846       };
44847     } catch (std::exception& e) {
44848       {
44849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44850       };
44851     } catch (...) {
44852       {
44853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44854       };
44855     }
44856   }
44857   jresult = (void *)result;
44858   return jresult;
44859 }
44860
44861
44862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
44863   void * jresult ;
44864   int arg1 ;
44865   std::vector< Dali::TouchPoint > *result = 0 ;
44866
44867   arg1 = (int)jarg1;
44868   {
44869     try {
44870       try {
44871         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
44872       }
44873       catch(std::out_of_range &_e) {
44874         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44875         return 0;
44876       }
44877
44878     } catch (std::out_of_range& e) {
44879       {
44880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44881       };
44882     } catch (std::exception& e) {
44883       {
44884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44885       };
44886     } catch (...) {
44887       {
44888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44889       };
44890     }
44891   }
44892   jresult = (void *)result;
44893   return jresult;
44894 }
44895
44896
44897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
44898   void * jresult ;
44899   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44900   int arg2 ;
44901   SwigValueWrapper< Dali::TouchPoint > result;
44902
44903   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44904   arg2 = (int)jarg2;
44905   {
44906     try {
44907       try {
44908         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
44909       }
44910       catch(std::out_of_range &_e) {
44911         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44912         return 0;
44913       }
44914
44915     } catch (std::out_of_range& e) {
44916       {
44917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44918       };
44919     } catch (std::exception& e) {
44920       {
44921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44922       };
44923     } catch (...) {
44924       {
44925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44926       };
44927     }
44928   }
44929   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
44930   return jresult;
44931 }
44932
44933
44934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
44935   void * jresult ;
44936   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44937   int arg2 ;
44938   Dali::TouchPoint *result = 0 ;
44939
44940   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44941   arg2 = (int)jarg2;
44942   {
44943     try {
44944       try {
44945         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
44946       }
44947       catch(std::out_of_range &_e) {
44948         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44949         return 0;
44950       }
44951
44952     } catch (std::out_of_range& e) {
44953       {
44954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44955       };
44956     } catch (std::exception& e) {
44957       {
44958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44959       };
44960     } catch (...) {
44961       {
44962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44963       };
44964     }
44965   }
44966   jresult = (void *)result;
44967   return jresult;
44968 }
44969
44970
44971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
44972   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44973   int arg2 ;
44974   Dali::TouchPoint *arg3 = 0 ;
44975
44976   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44977   arg2 = (int)jarg2;
44978   arg3 = (Dali::TouchPoint *)jarg3;
44979   if (!arg3) {
44980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
44981     return ;
44982   }
44983   {
44984     try {
44985       try {
44986         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
44987       }
44988       catch(std::out_of_range &_e) {
44989         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44990         return ;
44991       }
44992
44993     } catch (std::out_of_range& e) {
44994       {
44995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44996       };
44997     } catch (std::exception& e) {
44998       {
44999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45000       };
45001     } catch (...) {
45002       {
45003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45004       };
45005     }
45006   }
45007 }
45008
45009
45010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
45011   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45012   std::vector< Dali::TouchPoint > *arg2 = 0 ;
45013
45014   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45015   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
45016   if (!arg2) {
45017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45018     return ;
45019   }
45020   {
45021     try {
45022       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
45023     } catch (std::out_of_range& e) {
45024       {
45025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45026       };
45027     } catch (std::exception& e) {
45028       {
45029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45030       };
45031     } catch (...) {
45032       {
45033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45034       };
45035     }
45036   }
45037 }
45038
45039
45040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
45041   void * jresult ;
45042   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45043   int arg2 ;
45044   int arg3 ;
45045   std::vector< Dali::TouchPoint > *result = 0 ;
45046
45047   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45048   arg2 = (int)jarg2;
45049   arg3 = (int)jarg3;
45050   {
45051     try {
45052       try {
45053         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
45054       }
45055       catch(std::out_of_range &_e) {
45056         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45057         return 0;
45058       }
45059       catch(std::invalid_argument &_e) {
45060         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45061         return 0;
45062       }
45063
45064     } catch (std::out_of_range& e) {
45065       {
45066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45067       };
45068     } catch (std::exception& e) {
45069       {
45070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45071       };
45072     } catch (...) {
45073       {
45074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45075       };
45076     }
45077   }
45078   jresult = (void *)result;
45079   return jresult;
45080 }
45081
45082
45083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
45084   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45085   int arg2 ;
45086   Dali::TouchPoint *arg3 = 0 ;
45087
45088   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45089   arg2 = (int)jarg2;
45090   arg3 = (Dali::TouchPoint *)jarg3;
45091   if (!arg3) {
45092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45093     return ;
45094   }
45095   {
45096     try {
45097       try {
45098         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
45099       }
45100       catch(std::out_of_range &_e) {
45101         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45102         return ;
45103       }
45104
45105     } catch (std::out_of_range& e) {
45106       {
45107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45108       };
45109     } catch (std::exception& e) {
45110       {
45111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45112       };
45113     } catch (...) {
45114       {
45115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45116       };
45117     }
45118   }
45119 }
45120
45121
45122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
45123   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45124   int arg2 ;
45125   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45126
45127   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45128   arg2 = (int)jarg2;
45129   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45130   if (!arg3) {
45131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45132     return ;
45133   }
45134   {
45135     try {
45136       try {
45137         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45138       }
45139       catch(std::out_of_range &_e) {
45140         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45141         return ;
45142       }
45143
45144     } catch (std::out_of_range& e) {
45145       {
45146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45147       };
45148     } catch (std::exception& e) {
45149       {
45150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45151       };
45152     } catch (...) {
45153       {
45154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45155       };
45156     }
45157   }
45158 }
45159
45160
45161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
45162   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45163   int arg2 ;
45164
45165   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45166   arg2 = (int)jarg2;
45167   {
45168     try {
45169       try {
45170         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
45171       }
45172       catch(std::out_of_range &_e) {
45173         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45174         return ;
45175       }
45176
45177     } catch (std::out_of_range& e) {
45178       {
45179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45180       };
45181     } catch (std::exception& e) {
45182       {
45183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45184       };
45185     } catch (...) {
45186       {
45187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45188       };
45189     }
45190   }
45191 }
45192
45193
45194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
45195   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45196   int arg2 ;
45197   int arg3 ;
45198
45199   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45200   arg2 = (int)jarg2;
45201   arg3 = (int)jarg3;
45202   {
45203     try {
45204       try {
45205         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
45206       }
45207       catch(std::out_of_range &_e) {
45208         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45209         return ;
45210       }
45211       catch(std::invalid_argument &_e) {
45212         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45213         return ;
45214       }
45215
45216     } catch (std::out_of_range& e) {
45217       {
45218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45219       };
45220     } catch (std::exception& e) {
45221       {
45222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45223       };
45224     } catch (...) {
45225       {
45226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45227       };
45228     }
45229   }
45230 }
45231
45232
45233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
45234   void * jresult ;
45235   Dali::TouchPoint *arg1 = 0 ;
45236   int arg2 ;
45237   std::vector< Dali::TouchPoint > *result = 0 ;
45238
45239   arg1 = (Dali::TouchPoint *)jarg1;
45240   if (!arg1) {
45241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45242     return 0;
45243   }
45244   arg2 = (int)jarg2;
45245   {
45246     try {
45247       try {
45248         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
45249       }
45250       catch(std::out_of_range &_e) {
45251         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45252         return 0;
45253       }
45254
45255     } catch (std::out_of_range& e) {
45256       {
45257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45258       };
45259     } catch (std::exception& e) {
45260       {
45261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45262       };
45263     } catch (...) {
45264       {
45265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45266       };
45267     }
45268   }
45269   jresult = (void *)result;
45270   return jresult;
45271 }
45272
45273
45274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
45275   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45276
45277   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45278   {
45279     try {
45280       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
45281     } catch (std::out_of_range& e) {
45282       {
45283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45284       };
45285     } catch (std::exception& e) {
45286       {
45287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45288       };
45289     } catch (...) {
45290       {
45291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45292       };
45293     }
45294   }
45295 }
45296
45297
45298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
45299   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45300   int arg2 ;
45301   int arg3 ;
45302
45303   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45304   arg2 = (int)jarg2;
45305   arg3 = (int)jarg3;
45306   {
45307     try {
45308       try {
45309         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
45310       }
45311       catch(std::out_of_range &_e) {
45312         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45313         return ;
45314       }
45315       catch(std::invalid_argument &_e) {
45316         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45317         return ;
45318       }
45319
45320     } catch (std::out_of_range& e) {
45321       {
45322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45323       };
45324     } catch (std::exception& e) {
45325       {
45326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45327       };
45328     } catch (...) {
45329       {
45330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45331       };
45332     }
45333   }
45334 }
45335
45336
45337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
45338   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45339   int arg2 ;
45340   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45341
45342   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45343   arg2 = (int)jarg2;
45344   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45345   if (!arg3) {
45346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45347     return ;
45348   }
45349   {
45350     try {
45351       try {
45352         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45353       }
45354       catch(std::out_of_range &_e) {
45355         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45356         return ;
45357       }
45358
45359     } catch (std::out_of_range& e) {
45360       {
45361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45362       };
45363     } catch (std::exception& e) {
45364       {
45365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45366       };
45367     } catch (...) {
45368       {
45369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45370       };
45371     }
45372   }
45373 }
45374
45375
45376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
45377   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45378
45379   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45380   {
45381     try {
45382       delete arg1;
45383     } catch (std::out_of_range& e) {
45384       {
45385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45386       };
45387     } catch (std::exception& e) {
45388       {
45389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45390       };
45391     } catch (...) {
45392       {
45393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45394       };
45395     }
45396   }
45397 }
45398
45399
45400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
45401   void * jresult ;
45402   Dali::Rect< int > *result = 0 ;
45403
45404   {
45405     try {
45406       result = (Dali::Rect< int > *)new Dali::Rect< int >();
45407     } catch (std::out_of_range& e) {
45408       {
45409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45410       };
45411     } catch (std::exception& e) {
45412       {
45413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45414       };
45415     } catch (...) {
45416       {
45417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45418       };
45419     }
45420   }
45421   jresult = (void *)result;
45422   return jresult;
45423 }
45424
45425
45426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
45427   void * jresult ;
45428   int arg1 ;
45429   int arg2 ;
45430   int arg3 ;
45431   int arg4 ;
45432   Dali::Rect< int > *result = 0 ;
45433
45434   arg1 = (int)jarg1;
45435   arg2 = (int)jarg2;
45436   arg3 = (int)jarg3;
45437   arg4 = (int)jarg4;
45438   {
45439     try {
45440       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
45441     } catch (std::out_of_range& e) {
45442       {
45443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45444       };
45445     } catch (std::exception& e) {
45446       {
45447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45448       };
45449     } catch (...) {
45450       {
45451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45452       };
45453     }
45454   }
45455   jresult = (void *)result;
45456   return jresult;
45457 }
45458
45459
45460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
45461   void * jresult ;
45462   Dali::Rect< int > *arg1 = 0 ;
45463   Dali::Rect< int > *result = 0 ;
45464
45465   arg1 = (Dali::Rect< int > *)jarg1;
45466   if (!arg1) {
45467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45468     return 0;
45469   }
45470   {
45471     try {
45472       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
45473     } catch (std::out_of_range& e) {
45474       {
45475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45476       };
45477     } catch (std::exception& e) {
45478       {
45479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45480       };
45481     } catch (...) {
45482       {
45483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45484       };
45485     }
45486   }
45487   jresult = (void *)result;
45488   return jresult;
45489 }
45490
45491
45492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
45493   void * jresult ;
45494   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45495   Dali::Rect< int > *arg2 = 0 ;
45496   Dali::Rect< int > *result = 0 ;
45497
45498   arg1 = (Dali::Rect< int > *)jarg1;
45499   arg2 = (Dali::Rect< int > *)jarg2;
45500   if (!arg2) {
45501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45502     return 0;
45503   }
45504   {
45505     try {
45506       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
45507     } catch (std::out_of_range& e) {
45508       {
45509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45510       };
45511     } catch (std::exception& e) {
45512       {
45513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45514       };
45515     } catch (...) {
45516       {
45517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45518       };
45519     }
45520   }
45521   jresult = (void *)result;
45522   return jresult;
45523 }
45524
45525
45526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
45527   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45528   int arg2 ;
45529   int arg3 ;
45530   int arg4 ;
45531   int arg5 ;
45532
45533   arg1 = (Dali::Rect< int > *)jarg1;
45534   arg2 = (int)jarg2;
45535   arg3 = (int)jarg3;
45536   arg4 = (int)jarg4;
45537   arg5 = (int)jarg5;
45538   {
45539     try {
45540       (arg1)->Set(arg2,arg3,arg4,arg5);
45541     } catch (std::out_of_range& e) {
45542       {
45543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45544       };
45545     } catch (std::exception& e) {
45546       {
45547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45548       };
45549     } catch (...) {
45550       {
45551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45552       };
45553     }
45554   }
45555 }
45556
45557
45558 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
45559   unsigned int jresult ;
45560   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45561   bool result;
45562
45563   arg1 = (Dali::Rect< int > *)jarg1;
45564   {
45565     try {
45566       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
45567     } catch (std::out_of_range& e) {
45568       {
45569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45570       };
45571     } catch (std::exception& e) {
45572       {
45573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45574       };
45575     } catch (...) {
45576       {
45577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45578       };
45579     }
45580   }
45581   jresult = result;
45582   return jresult;
45583 }
45584
45585
45586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
45587   int jresult ;
45588   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45589   int result;
45590
45591   arg1 = (Dali::Rect< int > *)jarg1;
45592   {
45593     try {
45594       result = (int)((Dali::Rect< int > const *)arg1)->Left();
45595     } catch (std::out_of_range& e) {
45596       {
45597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45598       };
45599     } catch (std::exception& e) {
45600       {
45601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45602       };
45603     } catch (...) {
45604       {
45605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45606       };
45607     }
45608   }
45609   jresult = result;
45610   return jresult;
45611 }
45612
45613
45614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
45615   int jresult ;
45616   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45617   int result;
45618
45619   arg1 = (Dali::Rect< int > *)jarg1;
45620   {
45621     try {
45622       result = (int)((Dali::Rect< int > const *)arg1)->Right();
45623     } catch (std::out_of_range& e) {
45624       {
45625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45626       };
45627     } catch (std::exception& e) {
45628       {
45629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45630       };
45631     } catch (...) {
45632       {
45633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45634       };
45635     }
45636   }
45637   jresult = result;
45638   return jresult;
45639 }
45640
45641
45642 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
45643   int jresult ;
45644   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45645   int result;
45646
45647   arg1 = (Dali::Rect< int > *)jarg1;
45648   {
45649     try {
45650       result = (int)((Dali::Rect< int > const *)arg1)->Top();
45651     } catch (std::out_of_range& e) {
45652       {
45653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45654       };
45655     } catch (std::exception& e) {
45656       {
45657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45658       };
45659     } catch (...) {
45660       {
45661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45662       };
45663     }
45664   }
45665   jresult = result;
45666   return jresult;
45667 }
45668
45669
45670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
45671   int jresult ;
45672   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45673   int result;
45674
45675   arg1 = (Dali::Rect< int > *)jarg1;
45676   {
45677     try {
45678       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
45679     } catch (std::out_of_range& e) {
45680       {
45681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45682       };
45683     } catch (std::exception& e) {
45684       {
45685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45686       };
45687     } catch (...) {
45688       {
45689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45690       };
45691     }
45692   }
45693   jresult = result;
45694   return jresult;
45695 }
45696
45697
45698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
45699   int jresult ;
45700   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45701   int result;
45702
45703   arg1 = (Dali::Rect< int > *)jarg1;
45704   {
45705     try {
45706       result = (int)((Dali::Rect< int > const *)arg1)->Area();
45707     } catch (std::out_of_range& e) {
45708       {
45709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45710       };
45711     } catch (std::exception& e) {
45712       {
45713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45714       };
45715     } catch (...) {
45716       {
45717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45718       };
45719     }
45720   }
45721   jresult = result;
45722   return jresult;
45723 }
45724
45725
45726 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
45727   unsigned int jresult ;
45728   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45729   Dali::Rect< int > *arg2 = 0 ;
45730   bool result;
45731
45732   arg1 = (Dali::Rect< int > *)jarg1;
45733   arg2 = (Dali::Rect< int > *)jarg2;
45734   if (!arg2) {
45735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45736     return 0;
45737   }
45738   {
45739     try {
45740       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
45741     } catch (std::out_of_range& e) {
45742       {
45743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45744       };
45745     } catch (std::exception& e) {
45746       {
45747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45748       };
45749     } catch (...) {
45750       {
45751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45752       };
45753     }
45754   }
45755   jresult = result;
45756   return jresult;
45757 }
45758
45759
45760 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
45761   unsigned int jresult ;
45762   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45763   Dali::Rect< int > *arg2 = 0 ;
45764   bool result;
45765
45766   arg1 = (Dali::Rect< int > *)jarg1;
45767   arg2 = (Dali::Rect< int > *)jarg2;
45768   if (!arg2) {
45769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45770     return 0;
45771   }
45772   {
45773     try {
45774       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
45775     } catch (std::out_of_range& e) {
45776       {
45777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45778       };
45779     } catch (std::exception& e) {
45780       {
45781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45782       };
45783     } catch (...) {
45784       {
45785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45786       };
45787     }
45788   }
45789   jresult = result;
45790   return jresult;
45791 }
45792
45793
45794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
45795   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45796   int arg2 ;
45797
45798   arg1 = (Dali::Rect< int > *)jarg1;
45799   arg2 = (int)jarg2;
45800   if (arg1) (arg1)->x = arg2;
45801 }
45802
45803
45804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
45805   int jresult ;
45806   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45807   int result;
45808
45809   arg1 = (Dali::Rect< int > *)jarg1;
45810   result = (int) ((arg1)->x);
45811   jresult = result;
45812   return jresult;
45813 }
45814
45815
45816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
45817   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45818   int arg2 ;
45819
45820   arg1 = (Dali::Rect< int > *)jarg1;
45821   arg2 = (int)jarg2;
45822   if (arg1) (arg1)->left = arg2;
45823 }
45824
45825
45826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
45827   int jresult ;
45828   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45829   int result;
45830
45831   arg1 = (Dali::Rect< int > *)jarg1;
45832   result = (int) ((arg1)->left);
45833   jresult = result;
45834   return jresult;
45835 }
45836
45837
45838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
45839   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45840   int arg2 ;
45841
45842   arg1 = (Dali::Rect< int > *)jarg1;
45843   arg2 = (int)jarg2;
45844   if (arg1) (arg1)->y = arg2;
45845 }
45846
45847
45848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
45849   int jresult ;
45850   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45851   int result;
45852
45853   arg1 = (Dali::Rect< int > *)jarg1;
45854   result = (int) ((arg1)->y);
45855   jresult = result;
45856   return jresult;
45857 }
45858
45859
45860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
45861   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45862   int arg2 ;
45863
45864   arg1 = (Dali::Rect< int > *)jarg1;
45865   arg2 = (int)jarg2;
45866   if (arg1) (arg1)->right = arg2;
45867 }
45868
45869
45870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
45871   int jresult ;
45872   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45873   int result;
45874
45875   arg1 = (Dali::Rect< int > *)jarg1;
45876   result = (int) ((arg1)->right);
45877   jresult = result;
45878   return jresult;
45879 }
45880
45881
45882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
45883   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45884   int arg2 ;
45885
45886   arg1 = (Dali::Rect< int > *)jarg1;
45887   arg2 = (int)jarg2;
45888   if (arg1) (arg1)->width = arg2;
45889 }
45890
45891
45892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
45893   int jresult ;
45894   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45895   int result;
45896
45897   arg1 = (Dali::Rect< int > *)jarg1;
45898   result = (int) ((arg1)->width);
45899   jresult = result;
45900   return jresult;
45901 }
45902
45903
45904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
45905   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45906   int arg2 ;
45907
45908   arg1 = (Dali::Rect< int > *)jarg1;
45909   arg2 = (int)jarg2;
45910   if (arg1) (arg1)->bottom = arg2;
45911 }
45912
45913
45914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
45915   int jresult ;
45916   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45917   int result;
45918
45919   arg1 = (Dali::Rect< int > *)jarg1;
45920   result = (int) ((arg1)->bottom);
45921   jresult = result;
45922   return jresult;
45923 }
45924
45925
45926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
45927   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45928   int arg2 ;
45929
45930   arg1 = (Dali::Rect< int > *)jarg1;
45931   arg2 = (int)jarg2;
45932   if (arg1) (arg1)->height = arg2;
45933 }
45934
45935
45936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
45937   int jresult ;
45938   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45939   int result;
45940
45941   arg1 = (Dali::Rect< int > *)jarg1;
45942   result = (int) ((arg1)->height);
45943   jresult = result;
45944   return jresult;
45945 }
45946
45947
45948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
45949   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45950   int arg2 ;
45951
45952   arg1 = (Dali::Rect< int > *)jarg1;
45953   arg2 = (int)jarg2;
45954   if (arg1) (arg1)->top = arg2;
45955 }
45956
45957
45958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
45959   int jresult ;
45960   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45961   int result;
45962
45963   arg1 = (Dali::Rect< int > *)jarg1;
45964   result = (int) ((arg1)->top);
45965   jresult = result;
45966   return jresult;
45967 }
45968
45969
45970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
45971   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45972
45973   arg1 = (Dali::Rect< int > *)jarg1;
45974   {
45975     try {
45976       delete arg1;
45977     } catch (std::out_of_range& e) {
45978       {
45979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45980       };
45981     } catch (std::exception& e) {
45982       {
45983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45984       };
45985     } catch (...) {
45986       {
45987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45988       };
45989     }
45990   }
45991 }
45992
45993
45994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
45995   void * jresult ;
45996   Dali::Rect< float > *result = 0 ;
45997
45998   {
45999     try {
46000       result = (Dali::Rect< float > *)new Dali::Rect< float >();
46001     } catch (std::out_of_range& e) {
46002       {
46003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46004       };
46005     } catch (std::exception& e) {
46006       {
46007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46008       };
46009     } catch (...) {
46010       {
46011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46012       };
46013     }
46014   }
46015   jresult = (void *)result;
46016   return jresult;
46017 }
46018
46019
46020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
46021   void * jresult ;
46022   float arg1 ;
46023   float arg2 ;
46024   float arg3 ;
46025   float arg4 ;
46026   Dali::Rect< float > *result = 0 ;
46027
46028   arg1 = (float)jarg1;
46029   arg2 = (float)jarg2;
46030   arg3 = (float)jarg3;
46031   arg4 = (float)jarg4;
46032   {
46033     try {
46034       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
46035     } catch (std::out_of_range& e) {
46036       {
46037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46038       };
46039     } catch (std::exception& e) {
46040       {
46041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46042       };
46043     } catch (...) {
46044       {
46045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46046       };
46047     }
46048   }
46049   jresult = (void *)result;
46050   return jresult;
46051 }
46052
46053
46054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
46055   void * jresult ;
46056   Dali::Rect< float > *arg1 = 0 ;
46057   Dali::Rect< float > *result = 0 ;
46058
46059   arg1 = (Dali::Rect< float > *)jarg1;
46060   if (!arg1) {
46061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
46062     return 0;
46063   }
46064   {
46065     try {
46066       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
46067     } catch (std::out_of_range& e) {
46068       {
46069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46070       };
46071     } catch (std::exception& e) {
46072       {
46073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46074       };
46075     } catch (...) {
46076       {
46077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46078       };
46079     }
46080   }
46081   jresult = (void *)result;
46082   return jresult;
46083 }
46084
46085
46086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
46087   void * jresult ;
46088   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46089   Dali::Rect< float > *arg2 = 0 ;
46090   Dali::Rect< float > *result = 0 ;
46091
46092   arg1 = (Dali::Rect< float > *)jarg1;
46093   arg2 = (Dali::Rect< float > *)jarg2;
46094   if (!arg2) {
46095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
46096     return 0;
46097   }
46098   {
46099     try {
46100       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
46101     } catch (std::out_of_range& e) {
46102       {
46103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46104       };
46105     } catch (std::exception& e) {
46106       {
46107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46108       };
46109     } catch (...) {
46110       {
46111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46112       };
46113     }
46114   }
46115   jresult = (void *)result;
46116   return jresult;
46117 }
46118
46119
46120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
46121   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46122   float arg2 ;
46123   float arg3 ;
46124   float arg4 ;
46125   float arg5 ;
46126
46127   arg1 = (Dali::Rect< float > *)jarg1;
46128   arg2 = (float)jarg2;
46129   arg3 = (float)jarg3;
46130   arg4 = (float)jarg4;
46131   arg5 = (float)jarg5;
46132   {
46133     try {
46134       (arg1)->Set(arg2,arg3,arg4,arg5);
46135     } catch (std::out_of_range& e) {
46136       {
46137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46138       };
46139     } catch (std::exception& e) {
46140       {
46141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46142       };
46143     } catch (...) {
46144       {
46145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46146       };
46147     }
46148   }
46149 }
46150
46151
46152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_x_set(void * jarg1, float jarg2) {
46153   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46154   float arg2 ;
46155
46156   arg1 = (Dali::Rect< float > *)jarg1;
46157   arg2 = (float)jarg2;
46158   if (arg1) (arg1)->x = arg2;
46159 }
46160
46161
46162 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_x_get(void * jarg1) {
46163   float jresult ;
46164   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46165   float result;
46166
46167   arg1 = (Dali::Rect< float > *)jarg1;
46168   result = (float) ((arg1)->x);
46169   jresult = result;
46170   return jresult;
46171 }
46172
46173
46174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
46175   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46176   float arg2 ;
46177
46178   arg1 = (Dali::Rect< float > *)jarg1;
46179   arg2 = (float)jarg2;
46180   if (arg1) (arg1)->left = arg2;
46181 }
46182
46183
46184 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
46185   float jresult ;
46186   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46187   float result;
46188
46189   arg1 = (Dali::Rect< float > *)jarg1;
46190   result = (float) ((arg1)->left);
46191   jresult = result;
46192   return jresult;
46193 }
46194
46195
46196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_y_set(void * jarg1, float jarg2) {
46197   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46198   float arg2 ;
46199
46200   arg1 = (Dali::Rect< float > *)jarg1;
46201   arg2 = (float)jarg2;
46202   if (arg1) (arg1)->y = arg2;
46203 }
46204
46205
46206 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_y_get(void * jarg1) {
46207   float jresult ;
46208   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46209   float result;
46210
46211   arg1 = (Dali::Rect< float > *)jarg1;
46212   result = (float) ((arg1)->y);
46213   jresult = result;
46214   return jresult;
46215 }
46216
46217
46218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
46219   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46220   float arg2 ;
46221
46222   arg1 = (Dali::Rect< float > *)jarg1;
46223   arg2 = (float)jarg2;
46224   if (arg1) (arg1)->right = arg2;
46225 }
46226
46227
46228 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
46229   float jresult ;
46230   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46231   float result;
46232
46233   arg1 = (Dali::Rect< float > *)jarg1;
46234   result = (float) ((arg1)->right);
46235   jresult = result;
46236   return jresult;
46237 }
46238
46239
46240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_width_set(void * jarg1, float jarg2) {
46241   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46242   float arg2 ;
46243
46244   arg1 = (Dali::Rect< float > *)jarg1;
46245   arg2 = (float)jarg2;
46246   if (arg1) (arg1)->width = arg2;
46247 }
46248
46249
46250 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_width_get(void * jarg1) {
46251   float jresult ;
46252   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46253   float result;
46254
46255   arg1 = (Dali::Rect< float > *)jarg1;
46256   result = (float) ((arg1)->width);
46257   jresult = result;
46258   return jresult;
46259 }
46260
46261
46262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
46263   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46264   float arg2 ;
46265
46266   arg1 = (Dali::Rect< float > *)jarg1;
46267   arg2 = (float)jarg2;
46268   if (arg1) (arg1)->bottom = arg2;
46269 }
46270
46271
46272 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
46273   float jresult ;
46274   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46275   float result;
46276
46277   arg1 = (Dali::Rect< float > *)jarg1;
46278   result = (float) ((arg1)->bottom);
46279   jresult = result;
46280   return jresult;
46281 }
46282
46283
46284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_height_set(void * jarg1, float jarg2) {
46285   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46286   float arg2 ;
46287
46288   arg1 = (Dali::Rect< float > *)jarg1;
46289   arg2 = (float)jarg2;
46290   if (arg1) (arg1)->height = arg2;
46291 }
46292
46293
46294 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_height_get(void * jarg1) {
46295   float jresult ;
46296   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46297   float result;
46298
46299   arg1 = (Dali::Rect< float > *)jarg1;
46300   result = (float) ((arg1)->height);
46301   jresult = result;
46302   return jresult;
46303 }
46304
46305
46306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
46307   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46308   float arg2 ;
46309
46310   arg1 = (Dali::Rect< float > *)jarg1;
46311   arg2 = (float)jarg2;
46312   if (arg1) (arg1)->top = arg2;
46313 }
46314
46315
46316 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
46317   float jresult ;
46318   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46319   float result;
46320
46321   arg1 = (Dali::Rect< float > *)jarg1;
46322   result = (float) ((arg1)->top);
46323   jresult = result;
46324   return jresult;
46325 }
46326
46327
46328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
46329   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46330
46331   arg1 = (Dali::Rect< float > *)jarg1;
46332   {
46333     try {
46334       delete arg1;
46335     } catch (std::out_of_range& e) {
46336       {
46337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46338       };
46339     } catch (std::exception& e) {
46340       {
46341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46342       };
46343     } catch (...) {
46344       {
46345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46346       };
46347     }
46348   }
46349 }
46350
46351
46352 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
46353   int jresult ;
46354   int result;
46355
46356   result = (int)Dali::Vector< int >::BaseType;
46357   jresult = (int)result;
46358   return jresult;
46359 }
46360
46361
46362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
46363   void * jresult ;
46364   Dali::Vector< int > *result = 0 ;
46365
46366   {
46367     try {
46368       result = (Dali::Vector< int > *)new Dali::Vector< int >();
46369     } catch (std::out_of_range& e) {
46370       {
46371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46372       };
46373     } catch (std::exception& e) {
46374       {
46375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46376       };
46377     } catch (...) {
46378       {
46379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46380       };
46381     }
46382   }
46383   jresult = (void *)result;
46384   return jresult;
46385 }
46386
46387
46388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
46389   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46390
46391   arg1 = (Dali::Vector< int > *)jarg1;
46392   {
46393     try {
46394       delete arg1;
46395     } catch (std::out_of_range& e) {
46396       {
46397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46398       };
46399     } catch (std::exception& e) {
46400       {
46401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46402       };
46403     } catch (...) {
46404       {
46405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46406       };
46407     }
46408   }
46409 }
46410
46411
46412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
46413   void * jresult ;
46414   Dali::Vector< int > *arg1 = 0 ;
46415   Dali::Vector< int > *result = 0 ;
46416
46417   arg1 = (Dali::Vector< int > *)jarg1;
46418   if (!arg1) {
46419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
46420     return 0;
46421   }
46422   {
46423     try {
46424       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
46425     } catch (std::out_of_range& e) {
46426       {
46427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46428       };
46429     } catch (std::exception& e) {
46430       {
46431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46432       };
46433     } catch (...) {
46434       {
46435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46436       };
46437     }
46438   }
46439   jresult = (void *)result;
46440   return jresult;
46441 }
46442
46443
46444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
46445   void * jresult ;
46446   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46447   Dali::Vector< int > *arg2 = 0 ;
46448   Dali::Vector< int > *result = 0 ;
46449
46450   arg1 = (Dali::Vector< int > *)jarg1;
46451   arg2 = (Dali::Vector< int > *)jarg2;
46452   if (!arg2) {
46453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
46454     return 0;
46455   }
46456   {
46457     try {
46458       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
46459     } catch (std::out_of_range& e) {
46460       {
46461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46462       };
46463     } catch (std::exception& e) {
46464       {
46465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46466       };
46467     } catch (...) {
46468       {
46469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46470       };
46471     }
46472   }
46473   jresult = (void *)result;
46474   return jresult;
46475 }
46476
46477
46478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
46479   void * jresult ;
46480   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46481   Dali::Vector< int >::Iterator result;
46482
46483   arg1 = (Dali::Vector< int > *)jarg1;
46484   {
46485     try {
46486       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
46487     } catch (std::out_of_range& e) {
46488       {
46489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46490       };
46491     } catch (std::exception& e) {
46492       {
46493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46494       };
46495     } catch (...) {
46496       {
46497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46498       };
46499     }
46500   }
46501   jresult = (void *)result;
46502   return jresult;
46503 }
46504
46505
46506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
46507   void * jresult ;
46508   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46509   Dali::Vector< int >::Iterator result;
46510
46511   arg1 = (Dali::Vector< int > *)jarg1;
46512   {
46513     try {
46514       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
46515     } catch (std::out_of_range& e) {
46516       {
46517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46518       };
46519     } catch (std::exception& e) {
46520       {
46521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46522       };
46523     } catch (...) {
46524       {
46525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46526       };
46527     }
46528   }
46529   jresult = (void *)result;
46530   return jresult;
46531 }
46532
46533
46534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
46535   void * jresult ;
46536   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46537   Dali::Vector< int >::SizeType arg2 ;
46538   Dali::Vector< int >::ItemType *result = 0 ;
46539
46540   arg1 = (Dali::Vector< int > *)jarg1;
46541   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46542   {
46543     try {
46544       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
46545     } catch (std::out_of_range& e) {
46546       {
46547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46548       };
46549     } catch (std::exception& e) {
46550       {
46551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46552       };
46553     } catch (...) {
46554       {
46555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46556       };
46557     }
46558   }
46559   jresult = (void *)result;
46560   return jresult;
46561 }
46562
46563
46564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
46565   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46566   Dali::Vector< int >::ItemType *arg2 = 0 ;
46567   Dali::Vector< int >::ItemType temp2 ;
46568
46569   arg1 = (Dali::Vector< int > *)jarg1;
46570   temp2 = (Dali::Vector< int >::ItemType)jarg2;
46571   arg2 = &temp2;
46572   {
46573     try {
46574       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
46575     } catch (std::out_of_range& e) {
46576       {
46577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46578       };
46579     } catch (std::exception& e) {
46580       {
46581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46582       };
46583     } catch (...) {
46584       {
46585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46586       };
46587     }
46588   }
46589 }
46590
46591
46592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
46593   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46594   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46595   Dali::Vector< int >::ItemType *arg3 = 0 ;
46596   Dali::Vector< int >::ItemType temp3 ;
46597
46598   arg1 = (Dali::Vector< int > *)jarg1;
46599   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46600   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46601   arg3 = &temp3;
46602   {
46603     try {
46604       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
46605     } catch (std::out_of_range& e) {
46606       {
46607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46608       };
46609     } catch (std::exception& e) {
46610       {
46611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46612       };
46613     } catch (...) {
46614       {
46615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46616       };
46617     }
46618   }
46619 }
46620
46621
46622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
46623   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46624   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46625   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
46626   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
46627
46628   arg1 = (Dali::Vector< int > *)jarg1;
46629   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46630   arg3 = (Dali::Vector< int >::Iterator)jarg3;
46631   arg4 = (Dali::Vector< int >::Iterator)jarg4;
46632   {
46633     try {
46634       (arg1)->Insert(arg2,arg3,arg4);
46635     } catch (std::out_of_range& e) {
46636       {
46637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46638       };
46639     } catch (std::exception& e) {
46640       {
46641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46642       };
46643     } catch (...) {
46644       {
46645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46646       };
46647     }
46648   }
46649 }
46650
46651
46652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
46653   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46654   Dali::Vector< int >::SizeType arg2 ;
46655
46656   arg1 = (Dali::Vector< int > *)jarg1;
46657   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46658   {
46659     try {
46660       (arg1)->Reserve(arg2);
46661     } catch (std::out_of_range& e) {
46662       {
46663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46664       };
46665     } catch (std::exception& e) {
46666       {
46667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46668       };
46669     } catch (...) {
46670       {
46671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46672       };
46673     }
46674   }
46675 }
46676
46677
46678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
46679   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46680   Dali::Vector< int >::SizeType arg2 ;
46681
46682   arg1 = (Dali::Vector< int > *)jarg1;
46683   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46684   {
46685     try {
46686       (arg1)->Resize(arg2);
46687     } catch (std::out_of_range& e) {
46688       {
46689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46690       };
46691     } catch (std::exception& e) {
46692       {
46693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46694       };
46695     } catch (...) {
46696       {
46697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46698       };
46699     }
46700   }
46701 }
46702
46703
46704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
46705   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46706   Dali::Vector< int >::SizeType arg2 ;
46707   Dali::Vector< int >::ItemType *arg3 = 0 ;
46708   Dali::Vector< int >::ItemType temp3 ;
46709
46710   arg1 = (Dali::Vector< int > *)jarg1;
46711   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46712   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46713   arg3 = &temp3;
46714   {
46715     try {
46716       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
46717     } catch (std::out_of_range& e) {
46718       {
46719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46720       };
46721     } catch (std::exception& e) {
46722       {
46723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46724       };
46725     } catch (...) {
46726       {
46727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46728       };
46729     }
46730   }
46731 }
46732
46733
46734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
46735   void * jresult ;
46736   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46737   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46738   Dali::Vector< int >::Iterator result;
46739
46740   arg1 = (Dali::Vector< int > *)jarg1;
46741   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46742   {
46743     try {
46744       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
46745     } catch (std::out_of_range& e) {
46746       {
46747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46748       };
46749     } catch (std::exception& e) {
46750       {
46751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46752       };
46753     } catch (...) {
46754       {
46755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46756       };
46757     }
46758   }
46759   jresult = (void *)result;
46760   return jresult;
46761 }
46762
46763
46764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
46765   void * jresult ;
46766   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46767   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46768   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
46769   Dali::Vector< int >::Iterator result;
46770
46771   arg1 = (Dali::Vector< int > *)jarg1;
46772   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46773   arg3 = (Dali::Vector< int >::Iterator)jarg3;
46774   {
46775     try {
46776       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
46777     } catch (std::out_of_range& e) {
46778       {
46779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46780       };
46781     } catch (std::exception& e) {
46782       {
46783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46784       };
46785     } catch (...) {
46786       {
46787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46788       };
46789     }
46790   }
46791   jresult = (void *)result;
46792   return jresult;
46793 }
46794
46795
46796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
46797   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46798   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46799
46800   arg1 = (Dali::Vector< int > *)jarg1;
46801   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46802   {
46803     try {
46804       (arg1)->Remove(arg2);
46805     } catch (std::out_of_range& e) {
46806       {
46807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46808       };
46809     } catch (std::exception& e) {
46810       {
46811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46812       };
46813     } catch (...) {
46814       {
46815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46816       };
46817     }
46818   }
46819 }
46820
46821
46822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
46823   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46824   Dali::Vector< int > *arg2 = 0 ;
46825
46826   arg1 = (Dali::Vector< int > *)jarg1;
46827   arg2 = (Dali::Vector< int > *)jarg2;
46828   if (!arg2) {
46829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
46830     return ;
46831   }
46832   {
46833     try {
46834       (arg1)->Swap(*arg2);
46835     } catch (std::out_of_range& e) {
46836       {
46837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46838       };
46839     } catch (std::exception& e) {
46840       {
46841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46842       };
46843     } catch (...) {
46844       {
46845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46846       };
46847     }
46848   }
46849 }
46850
46851
46852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
46853   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46854
46855   arg1 = (Dali::Vector< int > *)jarg1;
46856   {
46857     try {
46858       (arg1)->Clear();
46859     } catch (std::out_of_range& e) {
46860       {
46861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46862       };
46863     } catch (std::exception& e) {
46864       {
46865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46866       };
46867     } catch (...) {
46868       {
46869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46870       };
46871     }
46872   }
46873 }
46874
46875
46876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
46877   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46878
46879   arg1 = (Dali::Vector< int > *)jarg1;
46880   {
46881     try {
46882       (arg1)->Release();
46883     } catch (std::out_of_range& e) {
46884       {
46885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46886       };
46887     } catch (std::exception& e) {
46888       {
46889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46890       };
46891     } catch (...) {
46892       {
46893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46894       };
46895     }
46896   }
46897 }
46898
46899
46900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
46901   int jresult ;
46902   int result;
46903
46904   result = (int)Dali::Vector< float >::BaseType;
46905   jresult = (int)result;
46906   return jresult;
46907 }
46908
46909
46910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
46911   void * jresult ;
46912   Dali::Vector< float > *result = 0 ;
46913
46914   {
46915     try {
46916       result = (Dali::Vector< float > *)new Dali::Vector< float >();
46917     } catch (std::out_of_range& e) {
46918       {
46919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46920       };
46921     } catch (std::exception& e) {
46922       {
46923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46924       };
46925     } catch (...) {
46926       {
46927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46928       };
46929     }
46930   }
46931   jresult = (void *)result;
46932   return jresult;
46933 }
46934
46935
46936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
46937   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46938
46939   arg1 = (Dali::Vector< float > *)jarg1;
46940   {
46941     try {
46942       delete arg1;
46943     } catch (std::out_of_range& e) {
46944       {
46945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46946       };
46947     } catch (std::exception& e) {
46948       {
46949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46950       };
46951     } catch (...) {
46952       {
46953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46954       };
46955     }
46956   }
46957 }
46958
46959
46960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
46961   void * jresult ;
46962   Dali::Vector< float > *arg1 = 0 ;
46963   Dali::Vector< float > *result = 0 ;
46964
46965   arg1 = (Dali::Vector< float > *)jarg1;
46966   if (!arg1) {
46967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
46968     return 0;
46969   }
46970   {
46971     try {
46972       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
46973     } catch (std::out_of_range& e) {
46974       {
46975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46976       };
46977     } catch (std::exception& e) {
46978       {
46979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46980       };
46981     } catch (...) {
46982       {
46983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46984       };
46985     }
46986   }
46987   jresult = (void *)result;
46988   return jresult;
46989 }
46990
46991
46992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
46993   void * jresult ;
46994   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46995   Dali::Vector< float > *arg2 = 0 ;
46996   Dali::Vector< float > *result = 0 ;
46997
46998   arg1 = (Dali::Vector< float > *)jarg1;
46999   arg2 = (Dali::Vector< float > *)jarg2;
47000   if (!arg2) {
47001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
47002     return 0;
47003   }
47004   {
47005     try {
47006       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
47007     } catch (std::out_of_range& e) {
47008       {
47009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47010       };
47011     } catch (std::exception& e) {
47012       {
47013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47014       };
47015     } catch (...) {
47016       {
47017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47018       };
47019     }
47020   }
47021   jresult = (void *)result;
47022   return jresult;
47023 }
47024
47025
47026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
47027   void * jresult ;
47028   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47029   Dali::Vector< float >::Iterator result;
47030
47031   arg1 = (Dali::Vector< float > *)jarg1;
47032   {
47033     try {
47034       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
47035     } catch (std::out_of_range& e) {
47036       {
47037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47038       };
47039     } catch (std::exception& e) {
47040       {
47041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47042       };
47043     } catch (...) {
47044       {
47045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47046       };
47047     }
47048   }
47049   jresult = (void *)result;
47050   return jresult;
47051 }
47052
47053
47054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
47055   void * jresult ;
47056   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47057   Dali::Vector< float >::Iterator result;
47058
47059   arg1 = (Dali::Vector< float > *)jarg1;
47060   {
47061     try {
47062       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
47063     } catch (std::out_of_range& e) {
47064       {
47065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47066       };
47067     } catch (std::exception& e) {
47068       {
47069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47070       };
47071     } catch (...) {
47072       {
47073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47074       };
47075     }
47076   }
47077   jresult = (void *)result;
47078   return jresult;
47079 }
47080
47081
47082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47083   void * jresult ;
47084   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47085   Dali::Vector< float >::SizeType arg2 ;
47086   Dali::Vector< float >::ItemType *result = 0 ;
47087
47088   arg1 = (Dali::Vector< float > *)jarg1;
47089   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47090   {
47091     try {
47092       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
47093     } catch (std::out_of_range& e) {
47094       {
47095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47096       };
47097     } catch (std::exception& e) {
47098       {
47099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47100       };
47101     } catch (...) {
47102       {
47103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47104       };
47105     }
47106   }
47107   jresult = (void *)result;
47108   return jresult;
47109 }
47110
47111
47112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
47113   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47114   Dali::Vector< float >::ItemType *arg2 = 0 ;
47115   Dali::Vector< float >::ItemType temp2 ;
47116
47117   arg1 = (Dali::Vector< float > *)jarg1;
47118   temp2 = (Dali::Vector< float >::ItemType)jarg2;
47119   arg2 = &temp2;
47120   {
47121     try {
47122       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
47123     } catch (std::out_of_range& e) {
47124       {
47125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47126       };
47127     } catch (std::exception& e) {
47128       {
47129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47130       };
47131     } catch (...) {
47132       {
47133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47134       };
47135     }
47136   }
47137 }
47138
47139
47140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
47141   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47142   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47143   Dali::Vector< float >::ItemType *arg3 = 0 ;
47144   Dali::Vector< float >::ItemType temp3 ;
47145
47146   arg1 = (Dali::Vector< float > *)jarg1;
47147   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47148   temp3 = (Dali::Vector< float >::ItemType)jarg3;
47149   arg3 = &temp3;
47150   {
47151     try {
47152       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
47153     } catch (std::out_of_range& e) {
47154       {
47155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47156       };
47157     } catch (std::exception& e) {
47158       {
47159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47160       };
47161     } catch (...) {
47162       {
47163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47164       };
47165     }
47166   }
47167 }
47168
47169
47170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
47171   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47172   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47173   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
47174   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
47175
47176   arg1 = (Dali::Vector< float > *)jarg1;
47177   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47178   arg3 = (Dali::Vector< float >::Iterator)jarg3;
47179   arg4 = (Dali::Vector< float >::Iterator)jarg4;
47180   {
47181     try {
47182       (arg1)->Insert(arg2,arg3,arg4);
47183     } catch (std::out_of_range& e) {
47184       {
47185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47186       };
47187     } catch (std::exception& e) {
47188       {
47189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47190       };
47191     } catch (...) {
47192       {
47193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47194       };
47195     }
47196   }
47197 }
47198
47199
47200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
47201   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47202   Dali::Vector< float >::SizeType arg2 ;
47203
47204   arg1 = (Dali::Vector< float > *)jarg1;
47205   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47206   {
47207     try {
47208       (arg1)->Reserve(arg2);
47209     } catch (std::out_of_range& e) {
47210       {
47211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47212       };
47213     } catch (std::exception& e) {
47214       {
47215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47216       };
47217     } catch (...) {
47218       {
47219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47220       };
47221     }
47222   }
47223 }
47224
47225
47226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47227   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47228   Dali::Vector< float >::SizeType arg2 ;
47229
47230   arg1 = (Dali::Vector< float > *)jarg1;
47231   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47232   {
47233     try {
47234       (arg1)->Resize(arg2);
47235     } catch (std::out_of_range& e) {
47236       {
47237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47238       };
47239     } catch (std::exception& e) {
47240       {
47241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47242       };
47243     } catch (...) {
47244       {
47245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47246       };
47247     }
47248   }
47249 }
47250
47251
47252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
47253   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47254   Dali::Vector< float >::SizeType arg2 ;
47255   Dali::Vector< float >::ItemType *arg3 = 0 ;
47256   Dali::Vector< float >::ItemType temp3 ;
47257
47258   arg1 = (Dali::Vector< float > *)jarg1;
47259   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47260   temp3 = (Dali::Vector< float >::ItemType)jarg3;
47261   arg3 = &temp3;
47262   {
47263     try {
47264       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
47265     } catch (std::out_of_range& e) {
47266       {
47267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47268       };
47269     } catch (std::exception& e) {
47270       {
47271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47272       };
47273     } catch (...) {
47274       {
47275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47276       };
47277     }
47278   }
47279 }
47280
47281
47282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
47283   void * jresult ;
47284   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47285   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47286   Dali::Vector< float >::Iterator result;
47287
47288   arg1 = (Dali::Vector< float > *)jarg1;
47289   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47290   {
47291     try {
47292       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
47293     } catch (std::out_of_range& e) {
47294       {
47295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47296       };
47297     } catch (std::exception& e) {
47298       {
47299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47300       };
47301     } catch (...) {
47302       {
47303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47304       };
47305     }
47306   }
47307   jresult = (void *)result;
47308   return jresult;
47309 }
47310
47311
47312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
47313   void * jresult ;
47314   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47315   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47316   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
47317   Dali::Vector< float >::Iterator result;
47318
47319   arg1 = (Dali::Vector< float > *)jarg1;
47320   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47321   arg3 = (Dali::Vector< float >::Iterator)jarg3;
47322   {
47323     try {
47324       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
47325     } catch (std::out_of_range& e) {
47326       {
47327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47328       };
47329     } catch (std::exception& e) {
47330       {
47331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47332       };
47333     } catch (...) {
47334       {
47335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47336       };
47337     }
47338   }
47339   jresult = (void *)result;
47340   return jresult;
47341 }
47342
47343
47344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
47345   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47346   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47347
47348   arg1 = (Dali::Vector< float > *)jarg1;
47349   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47350   {
47351     try {
47352       (arg1)->Remove(arg2);
47353     } catch (std::out_of_range& e) {
47354       {
47355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47356       };
47357     } catch (std::exception& e) {
47358       {
47359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47360       };
47361     } catch (...) {
47362       {
47363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47364       };
47365     }
47366   }
47367 }
47368
47369
47370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
47371   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47372   Dali::Vector< float > *arg2 = 0 ;
47373
47374   arg1 = (Dali::Vector< float > *)jarg1;
47375   arg2 = (Dali::Vector< float > *)jarg2;
47376   if (!arg2) {
47377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
47378     return ;
47379   }
47380   {
47381     try {
47382       (arg1)->Swap(*arg2);
47383     } catch (std::out_of_range& e) {
47384       {
47385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47386       };
47387     } catch (std::exception& e) {
47388       {
47389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47390       };
47391     } catch (...) {
47392       {
47393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47394       };
47395     }
47396   }
47397 }
47398
47399
47400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
47401   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47402
47403   arg1 = (Dali::Vector< float > *)jarg1;
47404   {
47405     try {
47406       (arg1)->Clear();
47407     } catch (std::out_of_range& e) {
47408       {
47409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47410       };
47411     } catch (std::exception& e) {
47412       {
47413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47414       };
47415     } catch (...) {
47416       {
47417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47418       };
47419     }
47420   }
47421 }
47422
47423
47424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
47425   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47426
47427   arg1 = (Dali::Vector< float > *)jarg1;
47428   {
47429     try {
47430       (arg1)->Release();
47431     } catch (std::out_of_range& e) {
47432       {
47433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47434       };
47435     } catch (std::exception& e) {
47436       {
47437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47438       };
47439     } catch (...) {
47440       {
47441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47442       };
47443     }
47444   }
47445 }
47446
47447
47448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
47449   int jresult ;
47450   int result;
47451
47452   result = (int)Dali::Vector< unsigned char >::BaseType;
47453   jresult = (int)result;
47454   return jresult;
47455 }
47456
47457
47458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
47459   void * jresult ;
47460   Dali::Vector< unsigned char > *result = 0 ;
47461
47462   {
47463     try {
47464       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
47465     } catch (std::out_of_range& e) {
47466       {
47467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47468       };
47469     } catch (std::exception& e) {
47470       {
47471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47472       };
47473     } catch (...) {
47474       {
47475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47476       };
47477     }
47478   }
47479   jresult = (void *)result;
47480   return jresult;
47481 }
47482
47483
47484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
47485   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47486
47487   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47488   {
47489     try {
47490       delete arg1;
47491     } catch (std::out_of_range& e) {
47492       {
47493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47494       };
47495     } catch (std::exception& e) {
47496       {
47497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47498       };
47499     } catch (...) {
47500       {
47501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47502       };
47503     }
47504   }
47505 }
47506
47507
47508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
47509   void * jresult ;
47510   Dali::Vector< unsigned char > *arg1 = 0 ;
47511   Dali::Vector< unsigned char > *result = 0 ;
47512
47513   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47514   if (!arg1) {
47515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47516     return 0;
47517   }
47518   {
47519     try {
47520       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
47521     } catch (std::out_of_range& e) {
47522       {
47523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47524       };
47525     } catch (std::exception& e) {
47526       {
47527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47528       };
47529     } catch (...) {
47530       {
47531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47532       };
47533     }
47534   }
47535   jresult = (void *)result;
47536   return jresult;
47537 }
47538
47539
47540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
47541   void * jresult ;
47542   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47543   Dali::Vector< unsigned char > *arg2 = 0 ;
47544   Dali::Vector< unsigned char > *result = 0 ;
47545
47546   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47547   arg2 = (Dali::Vector< unsigned char > *)jarg2;
47548   if (!arg2) {
47549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47550     return 0;
47551   }
47552   {
47553     try {
47554       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
47555     } catch (std::out_of_range& e) {
47556       {
47557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47558       };
47559     } catch (std::exception& e) {
47560       {
47561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47562       };
47563     } catch (...) {
47564       {
47565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47566       };
47567     }
47568   }
47569   jresult = (void *)result;
47570   return jresult;
47571 }
47572
47573
47574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
47575   void * jresult ;
47576   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47577   Dali::Vector< unsigned char >::Iterator result;
47578
47579   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47580   {
47581     try {
47582       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
47583     } catch (std::out_of_range& e) {
47584       {
47585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47586       };
47587     } catch (std::exception& e) {
47588       {
47589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47590       };
47591     } catch (...) {
47592       {
47593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47594       };
47595     }
47596   }
47597   jresult = (void *)result;
47598   return jresult;
47599 }
47600
47601
47602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
47603   void * jresult ;
47604   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47605   Dali::Vector< unsigned char >::Iterator result;
47606
47607   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47608   {
47609     try {
47610       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
47611     } catch (std::out_of_range& e) {
47612       {
47613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47614       };
47615     } catch (std::exception& e) {
47616       {
47617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47618       };
47619     } catch (...) {
47620       {
47621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47622       };
47623     }
47624   }
47625   jresult = (void *)result;
47626   return jresult;
47627 }
47628
47629
47630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47631   void * jresult ;
47632   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47633   Dali::Vector< unsigned char >::SizeType arg2 ;
47634   Dali::Vector< unsigned char >::ItemType *result = 0 ;
47635
47636   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47637   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47638   {
47639     try {
47640       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
47641     } catch (std::out_of_range& e) {
47642       {
47643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47644       };
47645     } catch (std::exception& e) {
47646       {
47647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47648       };
47649     } catch (...) {
47650       {
47651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47652       };
47653     }
47654   }
47655   jresult = (void *)result;
47656   return jresult;
47657 }
47658
47659
47660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
47661   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47662   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
47663   Dali::Vector< unsigned char >::ItemType temp2 ;
47664
47665   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47666   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
47667   arg2 = &temp2;
47668   {
47669     try {
47670       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
47671     } catch (std::out_of_range& e) {
47672       {
47673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47674       };
47675     } catch (std::exception& e) {
47676       {
47677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47678       };
47679     } catch (...) {
47680       {
47681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47682       };
47683     }
47684   }
47685 }
47686
47687
47688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
47689   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47690   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47691   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
47692   Dali::Vector< unsigned char >::ItemType temp3 ;
47693
47694   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47695   arg2 = jarg2;
47696   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
47697   arg3 = &temp3;
47698   {
47699     try {
47700       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
47701     } catch (std::out_of_range& e) {
47702       {
47703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47704       };
47705     } catch (std::exception& e) {
47706       {
47707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47708       };
47709     } catch (...) {
47710       {
47711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47712       };
47713     }
47714   }
47715
47716
47717 }
47718
47719
47720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
47721   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47722   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47723   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47724   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47725
47726   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47727   arg2 = jarg2;
47728   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
47729   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
47730   {
47731     try {
47732       (arg1)->Insert(arg2,arg3,arg4);
47733     } catch (std::out_of_range& e) {
47734       {
47735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47736       };
47737     } catch (std::exception& e) {
47738       {
47739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47740       };
47741     } catch (...) {
47742       {
47743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47744       };
47745     }
47746   }
47747
47748
47749 }
47750
47751
47752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
47753   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47754   Dali::Vector< unsigned char >::SizeType arg2 ;
47755
47756   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47757   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47758   {
47759     try {
47760       (arg1)->Reserve(arg2);
47761     } catch (std::out_of_range& e) {
47762       {
47763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47764       };
47765     } catch (std::exception& e) {
47766       {
47767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47768       };
47769     } catch (...) {
47770       {
47771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47772       };
47773     }
47774   }
47775 }
47776
47777
47778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47779   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47780   Dali::Vector< unsigned char >::SizeType arg2 ;
47781
47782   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47783   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47784   {
47785     try {
47786       (arg1)->Resize(arg2);
47787     } catch (std::out_of_range& e) {
47788       {
47789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47790       };
47791     } catch (std::exception& e) {
47792       {
47793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47794       };
47795     } catch (...) {
47796       {
47797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47798       };
47799     }
47800   }
47801 }
47802
47803
47804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
47805   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47806   Dali::Vector< unsigned char >::SizeType arg2 ;
47807   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
47808   Dali::Vector< unsigned char >::ItemType temp3 ;
47809
47810   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47811   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47812   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
47813   arg3 = &temp3;
47814   {
47815     try {
47816       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
47817     } catch (std::out_of_range& e) {
47818       {
47819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47820       };
47821     } catch (std::exception& e) {
47822       {
47823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47824       };
47825     } catch (...) {
47826       {
47827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47828       };
47829     }
47830   }
47831 }
47832
47833
47834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
47835   void * jresult ;
47836   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47837   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47838   Dali::Vector< unsigned char >::Iterator result;
47839
47840   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47841   arg2 = jarg2;
47842   {
47843     try {
47844       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
47845     } catch (std::out_of_range& e) {
47846       {
47847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47848       };
47849     } catch (std::exception& e) {
47850       {
47851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47852       };
47853     } catch (...) {
47854       {
47855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47856       };
47857     }
47858   }
47859   jresult = (void *)result;
47860
47861
47862   return jresult;
47863 }
47864
47865
47866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
47867   void * jresult ;
47868   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47869   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47870   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47871   Dali::Vector< unsigned char >::Iterator result;
47872
47873   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47874   arg2 = jarg2;
47875   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
47876   {
47877     try {
47878       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
47879     } catch (std::out_of_range& e) {
47880       {
47881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47882       };
47883     } catch (std::exception& e) {
47884       {
47885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47886       };
47887     } catch (...) {
47888       {
47889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47890       };
47891     }
47892   }
47893   jresult = (void *)result;
47894
47895
47896   return jresult;
47897 }
47898
47899
47900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
47901   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47902   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47903
47904   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47905   arg2 = jarg2;
47906   {
47907     try {
47908       (arg1)->Remove(arg2);
47909     } catch (std::out_of_range& e) {
47910       {
47911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47912       };
47913     } catch (std::exception& e) {
47914       {
47915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47916       };
47917     } catch (...) {
47918       {
47919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47920       };
47921     }
47922   }
47923
47924
47925 }
47926
47927
47928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
47929   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47930   Dali::Vector< unsigned char > *arg2 = 0 ;
47931
47932   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47933   arg2 = (Dali::Vector< unsigned char > *)jarg2;
47934   if (!arg2) {
47935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
47936     return ;
47937   }
47938   {
47939     try {
47940       (arg1)->Swap(*arg2);
47941     } catch (std::out_of_range& e) {
47942       {
47943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47944       };
47945     } catch (std::exception& e) {
47946       {
47947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47948       };
47949     } catch (...) {
47950       {
47951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47952       };
47953     }
47954   }
47955 }
47956
47957
47958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
47959   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47960
47961   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47962   {
47963     try {
47964       (arg1)->Clear();
47965     } catch (std::out_of_range& e) {
47966       {
47967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47968       };
47969     } catch (std::exception& e) {
47970       {
47971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47972       };
47973     } catch (...) {
47974       {
47975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47976       };
47977     }
47978   }
47979 }
47980
47981
47982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
47983   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47984
47985   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47986   {
47987     try {
47988       (arg1)->Release();
47989     } catch (std::out_of_range& e) {
47990       {
47991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47992       };
47993     } catch (std::exception& e) {
47994       {
47995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47996       };
47997     } catch (...) {
47998       {
47999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48000       };
48001     }
48002   }
48003 }
48004
48005
48006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
48007   int jresult ;
48008   int result;
48009
48010   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
48011   jresult = (int)result;
48012   return jresult;
48013 }
48014
48015
48016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
48017   void * jresult ;
48018   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48019
48020   {
48021     try {
48022       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
48023     } catch (std::out_of_range& e) {
48024       {
48025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48026       };
48027     } catch (std::exception& e) {
48028       {
48029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48030       };
48031     } catch (...) {
48032       {
48033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48034       };
48035     }
48036   }
48037   jresult = (void *)result;
48038   return jresult;
48039 }
48040
48041
48042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
48043   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48044
48045   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48046   {
48047     try {
48048       delete arg1;
48049     } catch (std::out_of_range& e) {
48050       {
48051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48052       };
48053     } catch (std::exception& e) {
48054       {
48055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48056       };
48057     } catch (...) {
48058       {
48059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48060       };
48061     }
48062   }
48063 }
48064
48065
48066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
48067   void * jresult ;
48068   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
48069   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48070
48071   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48072   if (!arg1) {
48073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
48074     return 0;
48075   }
48076   {
48077     try {
48078       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
48079     } catch (std::out_of_range& e) {
48080       {
48081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48082       };
48083     } catch (std::exception& e) {
48084       {
48085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48086       };
48087     } catch (...) {
48088       {
48089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48090       };
48091     }
48092   }
48093   jresult = (void *)result;
48094   return jresult;
48095 }
48096
48097
48098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
48099   void * jresult ;
48100   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48101   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
48102   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48103
48104   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48105   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
48106   if (!arg2) {
48107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
48108     return 0;
48109   }
48110   {
48111     try {
48112       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
48113     } catch (std::out_of_range& e) {
48114       {
48115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48116       };
48117     } catch (std::exception& e) {
48118       {
48119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48120       };
48121     } catch (...) {
48122       {
48123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48124       };
48125     }
48126   }
48127   jresult = (void *)result;
48128   return jresult;
48129 }
48130
48131
48132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
48133   void * jresult ;
48134   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48135   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48136
48137   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48138   {
48139     try {
48140       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
48141     } catch (std::out_of_range& e) {
48142       {
48143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48144       };
48145     } catch (std::exception& e) {
48146       {
48147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48148       };
48149     } catch (...) {
48150       {
48151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48152       };
48153     }
48154   }
48155   jresult = (void *)result;
48156   return jresult;
48157 }
48158
48159
48160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
48161   void * jresult ;
48162   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48163   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48164
48165   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48166   {
48167     try {
48168       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
48169     } catch (std::out_of_range& e) {
48170       {
48171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48172       };
48173     } catch (std::exception& e) {
48174       {
48175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48176       };
48177     } catch (...) {
48178       {
48179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48180       };
48181     }
48182   }
48183   jresult = (void *)result;
48184   return jresult;
48185 }
48186
48187
48188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48189   void * jresult ;
48190   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48191   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48192   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
48193
48194   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48195   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48196   {
48197     try {
48198       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
48199     } catch (std::out_of_range& e) {
48200       {
48201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48202       };
48203     } catch (std::exception& e) {
48204       {
48205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48206       };
48207     } catch (...) {
48208       {
48209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48210       };
48211     }
48212   }
48213   jresult = (void *)result;
48214   return jresult;
48215 }
48216
48217
48218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
48219   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48220   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
48221
48222   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48223   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
48224   if (!arg2) {
48225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48226     return ;
48227   }
48228   {
48229     try {
48230       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
48231     } catch (std::out_of_range& e) {
48232       {
48233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48234       };
48235     } catch (std::exception& e) {
48236       {
48237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48238       };
48239     } catch (...) {
48240       {
48241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48242       };
48243     }
48244   }
48245 }
48246
48247
48248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
48249   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48250   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48251   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
48252
48253   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48254   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48255   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
48256   if (!arg3) {
48257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48258     return ;
48259   }
48260   {
48261     try {
48262       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
48263     } catch (std::out_of_range& e) {
48264       {
48265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48266       };
48267     } catch (std::exception& e) {
48268       {
48269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48270       };
48271     } catch (...) {
48272       {
48273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48274       };
48275     }
48276   }
48277 }
48278
48279
48280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48281   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48282   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48283   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48284   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48285
48286   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48287   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48288   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
48289   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
48290   {
48291     try {
48292       (arg1)->Insert(arg2,arg3,arg4);
48293     } catch (std::out_of_range& e) {
48294       {
48295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48296       };
48297     } catch (std::exception& e) {
48298       {
48299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48300       };
48301     } catch (...) {
48302       {
48303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48304       };
48305     }
48306   }
48307 }
48308
48309
48310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
48311   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48312   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48313
48314   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48315   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48316   {
48317     try {
48318       (arg1)->Reserve(arg2);
48319     } catch (std::out_of_range& e) {
48320       {
48321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48322       };
48323     } catch (std::exception& e) {
48324       {
48325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48326       };
48327     } catch (...) {
48328       {
48329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48330       };
48331     }
48332   }
48333 }
48334
48335
48336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48337   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48338   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48339
48340   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48341   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48342   {
48343     try {
48344       (arg1)->Resize(arg2);
48345     } catch (std::out_of_range& e) {
48346       {
48347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48348       };
48349     } catch (std::exception& e) {
48350       {
48351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48352       };
48353     } catch (...) {
48354       {
48355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48356       };
48357     }
48358   }
48359 }
48360
48361
48362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
48363   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48364   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48365   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
48366
48367   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48368   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48369   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
48370   if (!arg3) {
48371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48372     return ;
48373   }
48374   {
48375     try {
48376       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
48377     } catch (std::out_of_range& e) {
48378       {
48379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48380       };
48381     } catch (std::exception& e) {
48382       {
48383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48384       };
48385     } catch (...) {
48386       {
48387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48388       };
48389     }
48390   }
48391 }
48392
48393
48394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
48395   void * jresult ;
48396   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48397   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48398   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48399
48400   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48401   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48402   {
48403     try {
48404       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
48405     } catch (std::out_of_range& e) {
48406       {
48407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48408       };
48409     } catch (std::exception& e) {
48410       {
48411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48412       };
48413     } catch (...) {
48414       {
48415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48416       };
48417     }
48418   }
48419   jresult = (void *)result;
48420   return jresult;
48421 }
48422
48423
48424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48425   void * jresult ;
48426   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48427   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48428   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48429   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48430
48431   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48432   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48433   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
48434   {
48435     try {
48436       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
48437     } catch (std::out_of_range& e) {
48438       {
48439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48440       };
48441     } catch (std::exception& e) {
48442       {
48443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48444       };
48445     } catch (...) {
48446       {
48447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48448       };
48449     }
48450   }
48451   jresult = (void *)result;
48452   return jresult;
48453 }
48454
48455
48456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
48457   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48458   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48459
48460   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48461   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48462   {
48463     try {
48464       (arg1)->Remove(arg2);
48465     } catch (std::out_of_range& e) {
48466       {
48467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48468       };
48469     } catch (std::exception& e) {
48470       {
48471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48472       };
48473     } catch (...) {
48474       {
48475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48476       };
48477     }
48478   }
48479 }
48480
48481
48482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
48483   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48484   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
48485
48486   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48487   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
48488   if (!arg2) {
48489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
48490     return ;
48491   }
48492   {
48493     try {
48494       (arg1)->Swap(*arg2);
48495     } catch (std::out_of_range& e) {
48496       {
48497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48498       };
48499     } catch (std::exception& e) {
48500       {
48501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48502       };
48503     } catch (...) {
48504       {
48505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48506       };
48507     }
48508   }
48509 }
48510
48511
48512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
48513   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48514
48515   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48516   {
48517     try {
48518       (arg1)->Clear();
48519     } catch (std::out_of_range& e) {
48520       {
48521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48522       };
48523     } catch (std::exception& e) {
48524       {
48525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48526       };
48527     } catch (...) {
48528       {
48529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48530       };
48531     }
48532   }
48533 }
48534
48535
48536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
48537   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48538
48539   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48540   {
48541     try {
48542       (arg1)->Release();
48543     } catch (std::out_of_range& e) {
48544       {
48545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48546       };
48547     } catch (std::exception& e) {
48548       {
48549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48550       };
48551     } catch (...) {
48552       {
48553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48554       };
48555     }
48556   }
48557 }
48558
48559
48560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
48561   void * jresult ;
48562   Dali::Signal< void () > *result = 0 ;
48563
48564   {
48565     try {
48566       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
48567     } catch (std::out_of_range& e) {
48568       {
48569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48570       };
48571     } catch (std::exception& e) {
48572       {
48573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48574       };
48575     } catch (...) {
48576       {
48577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48578       };
48579     }
48580   }
48581   jresult = (void *)result;
48582   return jresult;
48583 }
48584
48585
48586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
48587   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48588
48589   arg1 = (Dali::Signal< void () > *)jarg1;
48590   {
48591     try {
48592       delete arg1;
48593     } catch (std::out_of_range& e) {
48594       {
48595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48596       };
48597     } catch (std::exception& e) {
48598       {
48599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48600       };
48601     } catch (...) {
48602       {
48603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48604       };
48605     }
48606   }
48607 }
48608
48609
48610 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
48611   unsigned int jresult ;
48612   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48613   bool result;
48614
48615   arg1 = (Dali::Signal< void () > *)jarg1;
48616   {
48617     try {
48618       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
48619     } catch (std::out_of_range& e) {
48620       {
48621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48622       };
48623     } catch (std::exception& e) {
48624       {
48625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48626       };
48627     } catch (...) {
48628       {
48629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48630       };
48631     }
48632   }
48633   jresult = result;
48634   return jresult;
48635 }
48636
48637
48638 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
48639   unsigned long jresult ;
48640   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48641   std::size_t result;
48642
48643   arg1 = (Dali::Signal< void () > *)jarg1;
48644   {
48645     try {
48646       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
48647     } catch (std::out_of_range& e) {
48648       {
48649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48650       };
48651     } catch (std::exception& e) {
48652       {
48653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48654       };
48655     } catch (...) {
48656       {
48657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48658       };
48659     }
48660   }
48661   jresult = (unsigned long)result;
48662   return jresult;
48663 }
48664
48665
48666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
48667   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48668   void (*arg2)() = (void (*)()) 0 ;
48669
48670   arg1 = (Dali::Signal< void () > *)jarg1;
48671   arg2 = (void (*)())jarg2;
48672   {
48673     try {
48674       (arg1)->Connect(arg2);
48675     } catch (std::out_of_range& e) {
48676       {
48677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48678       };
48679     } catch (std::exception& e) {
48680       {
48681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48682       };
48683     } catch (...) {
48684       {
48685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48686       };
48687     }
48688   }
48689 }
48690
48691
48692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
48693   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48694   void (*arg2)() = (void (*)()) 0 ;
48695
48696   arg1 = (Dali::Signal< void () > *)jarg1;
48697   arg2 = (void (*)())jarg2;
48698   {
48699     try {
48700       (arg1)->Disconnect(arg2);
48701     } catch (std::out_of_range& e) {
48702       {
48703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48704       };
48705     } catch (std::exception& e) {
48706       {
48707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48708       };
48709     } catch (...) {
48710       {
48711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48712       };
48713     }
48714   }
48715 }
48716
48717
48718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
48719   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48720   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
48721   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
48722
48723   arg1 = (Dali::Signal< void () > *)jarg1;
48724   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
48725   arg3 = (Dali::FunctorDelegate *)jarg3;
48726   {
48727     try {
48728       (arg1)->Connect(arg2,arg3);
48729     } catch (std::out_of_range& e) {
48730       {
48731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48732       };
48733     } catch (std::exception& e) {
48734       {
48735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48736       };
48737     } catch (...) {
48738       {
48739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48740       };
48741     }
48742   }
48743 }
48744
48745
48746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
48747   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48748
48749   arg1 = (Dali::Signal< void () > *)jarg1;
48750   {
48751     try {
48752       (arg1)->Emit();
48753     } catch (std::out_of_range& e) {
48754       {
48755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48756       };
48757     } catch (std::exception& e) {
48758       {
48759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48760       };
48761     } catch (...) {
48762       {
48763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48764       };
48765     }
48766   }
48767 }
48768
48769
48770 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
48771   unsigned int jresult ;
48772   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48773   bool result;
48774
48775   arg1 = (Dali::Signal< void (float) > *)jarg1;
48776   {
48777     try {
48778       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
48779     } catch (std::out_of_range& e) {
48780       {
48781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48782       };
48783     } catch (std::exception& e) {
48784       {
48785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48786       };
48787     } catch (...) {
48788       {
48789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48790       };
48791     }
48792   }
48793   jresult = result;
48794   return jresult;
48795 }
48796
48797
48798 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
48799   unsigned long jresult ;
48800   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48801   std::size_t result;
48802
48803   arg1 = (Dali::Signal< void (float) > *)jarg1;
48804   {
48805     try {
48806       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
48807     } catch (std::out_of_range& e) {
48808       {
48809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48810       };
48811     } catch (std::exception& e) {
48812       {
48813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48814       };
48815     } catch (...) {
48816       {
48817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48818       };
48819     }
48820   }
48821   jresult = (unsigned long)result;
48822   return jresult;
48823 }
48824
48825
48826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
48827   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48828   void (*arg2)(float) = (void (*)(float)) 0 ;
48829
48830   arg1 = (Dali::Signal< void (float) > *)jarg1;
48831   arg2 = (void (*)(float))jarg2;
48832   {
48833     try {
48834       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
48835     } catch (std::out_of_range& e) {
48836       {
48837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48838       };
48839     } catch (std::exception& e) {
48840       {
48841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48842       };
48843     } catch (...) {
48844       {
48845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48846       };
48847     }
48848   }
48849 }
48850
48851
48852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
48853   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48854   void (*arg2)(float) = (void (*)(float)) 0 ;
48855
48856   arg1 = (Dali::Signal< void (float) > *)jarg1;
48857   arg2 = (void (*)(float))jarg2;
48858   {
48859     try {
48860       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
48861     } catch (std::out_of_range& e) {
48862       {
48863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48864       };
48865     } catch (std::exception& e) {
48866       {
48867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48868       };
48869     } catch (...) {
48870       {
48871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48872       };
48873     }
48874   }
48875 }
48876
48877
48878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
48879   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48880   float arg2 ;
48881
48882   arg1 = (Dali::Signal< void (float) > *)jarg1;
48883   arg2 = (float)jarg2;
48884   {
48885     try {
48886       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
48887     } catch (std::out_of_range& e) {
48888       {
48889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48890       };
48891     } catch (std::exception& e) {
48892       {
48893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48894       };
48895     } catch (...) {
48896       {
48897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48898       };
48899     }
48900   }
48901 }
48902
48903
48904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
48905   void * jresult ;
48906   Dali::Signal< void (float) > *result = 0 ;
48907
48908   {
48909     try {
48910       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
48911     } catch (std::out_of_range& e) {
48912       {
48913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48914       };
48915     } catch (std::exception& e) {
48916       {
48917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48918       };
48919     } catch (...) {
48920       {
48921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48922       };
48923     }
48924   }
48925   jresult = (void *)result;
48926   return jresult;
48927 }
48928
48929
48930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
48931   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48932
48933   arg1 = (Dali::Signal< void (float) > *)jarg1;
48934   {
48935     try {
48936       delete arg1;
48937     } catch (std::out_of_range& e) {
48938       {
48939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48940       };
48941     } catch (std::exception& e) {
48942       {
48943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48944       };
48945     } catch (...) {
48946       {
48947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48948       };
48949     }
48950   }
48951 }
48952
48953
48954 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
48955   unsigned int jresult ;
48956   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
48957   bool result;
48958
48959   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
48960   {
48961     try {
48962       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
48963     } catch (std::out_of_range& e) {
48964       {
48965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48966       };
48967     } catch (std::exception& e) {
48968       {
48969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48970       };
48971     } catch (...) {
48972       {
48973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48974       };
48975     }
48976   }
48977   jresult = result;
48978   return jresult;
48979 }
48980
48981
48982 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
48983   unsigned long jresult ;
48984   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
48985   std::size_t result;
48986
48987   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
48988   {
48989     try {
48990       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
48991     } catch (std::out_of_range& e) {
48992       {
48993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48994       };
48995     } catch (std::exception& e) {
48996       {
48997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48998       };
48999     } catch (...) {
49000       {
49001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49002       };
49003     }
49004   }
49005   jresult = (unsigned long)result;
49006   return jresult;
49007 }
49008
49009
49010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
49011   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49012   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
49013
49014   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49015   arg2 = (void (*)(Dali::BaseHandle))jarg2;
49016   {
49017     try {
49018       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
49019     } catch (std::out_of_range& e) {
49020       {
49021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49022       };
49023     } catch (std::exception& e) {
49024       {
49025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49026       };
49027     } catch (...) {
49028       {
49029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49030       };
49031     }
49032   }
49033 }
49034
49035
49036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
49037   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49038   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
49039
49040   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49041   arg2 = (void (*)(Dali::BaseHandle))jarg2;
49042   {
49043     try {
49044       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
49045     } catch (std::out_of_range& e) {
49046       {
49047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49048       };
49049     } catch (std::exception& e) {
49050       {
49051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49052       };
49053     } catch (...) {
49054       {
49055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49056       };
49057     }
49058   }
49059 }
49060
49061
49062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
49063   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49064   Dali::BaseHandle arg2 ;
49065   Dali::BaseHandle *argp2 ;
49066
49067   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49068   argp2 = (Dali::BaseHandle *)jarg2;
49069   if (!argp2) {
49070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49071     return ;
49072   }
49073   arg2 = *argp2;
49074   {
49075     try {
49076       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
49077     } catch (std::out_of_range& e) {
49078       {
49079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49080       };
49081     } catch (std::exception& e) {
49082       {
49083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49084       };
49085     } catch (...) {
49086       {
49087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49088       };
49089     }
49090   }
49091 }
49092
49093
49094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
49095   void * jresult ;
49096   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
49097
49098   {
49099     try {
49100       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
49101     } catch (std::out_of_range& e) {
49102       {
49103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49104       };
49105     } catch (std::exception& e) {
49106       {
49107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49108       };
49109     } catch (...) {
49110       {
49111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49112       };
49113     }
49114   }
49115   jresult = (void *)result;
49116   return jresult;
49117 }
49118
49119
49120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
49121   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49122
49123   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49124   {
49125     try {
49126       delete arg1;
49127     } catch (std::out_of_range& e) {
49128       {
49129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49130       };
49131     } catch (std::exception& e) {
49132       {
49133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49134       };
49135     } catch (...) {
49136       {
49137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49138       };
49139     }
49140   }
49141 }
49142
49143
49144 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
49145   unsigned int jresult ;
49146   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49147   bool result;
49148
49149   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49150   {
49151     try {
49152       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
49153     } catch (std::out_of_range& e) {
49154       {
49155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49156       };
49157     } catch (std::exception& e) {
49158       {
49159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49160       };
49161     } catch (...) {
49162       {
49163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49164       };
49165     }
49166   }
49167   jresult = result;
49168   return jresult;
49169 }
49170
49171
49172 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
49173   unsigned long jresult ;
49174   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49175   std::size_t result;
49176
49177   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49178   {
49179     try {
49180       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
49181     } catch (std::out_of_range& e) {
49182       {
49183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49184       };
49185     } catch (std::exception& e) {
49186       {
49187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49188       };
49189     } catch (...) {
49190       {
49191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49192       };
49193     }
49194   }
49195   jresult = (unsigned long)result;
49196   return jresult;
49197 }
49198
49199
49200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
49201   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49202   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
49203
49204   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49205   arg2 = (void (*)(Dali::RefObject const *))jarg2;
49206   {
49207     try {
49208       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
49209     } catch (std::out_of_range& e) {
49210       {
49211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49212       };
49213     } catch (std::exception& e) {
49214       {
49215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49216       };
49217     } catch (...) {
49218       {
49219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49220       };
49221     }
49222   }
49223 }
49224
49225
49226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
49227   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49228   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
49229
49230   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49231   arg2 = (void (*)(Dali::RefObject const *))jarg2;
49232   {
49233     try {
49234       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
49235     } catch (std::out_of_range& e) {
49236       {
49237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49238       };
49239     } catch (std::exception& e) {
49240       {
49241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49242       };
49243     } catch (...) {
49244       {
49245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49246       };
49247     }
49248   }
49249 }
49250
49251
49252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
49253   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49254   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
49255
49256   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49257   arg2 = (Dali::RefObject *)jarg2;
49258   {
49259     try {
49260       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
49261     } catch (std::out_of_range& e) {
49262       {
49263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49264       };
49265     } catch (std::exception& e) {
49266       {
49267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49268       };
49269     } catch (...) {
49270       {
49271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49272       };
49273     }
49274   }
49275 }
49276
49277
49278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
49279   void * jresult ;
49280   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
49281
49282   {
49283     try {
49284       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
49285     } catch (std::out_of_range& e) {
49286       {
49287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49288       };
49289     } catch (std::exception& e) {
49290       {
49291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49292       };
49293     } catch (...) {
49294       {
49295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49296       };
49297     }
49298   }
49299   jresult = (void *)result;
49300   return jresult;
49301 }
49302
49303
49304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
49305   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49306
49307   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49308   {
49309     try {
49310       delete arg1;
49311     } catch (std::out_of_range& e) {
49312       {
49313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49314       };
49315     } catch (std::exception& e) {
49316       {
49317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49318       };
49319     } catch (...) {
49320       {
49321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49322       };
49323     }
49324   }
49325 }
49326
49327
49328 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
49329   unsigned int jresult ;
49330   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49331   bool result;
49332
49333   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49334   {
49335     try {
49336       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
49337     } catch (std::out_of_range& e) {
49338       {
49339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49340       };
49341     } catch (std::exception& e) {
49342       {
49343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49344       };
49345     } catch (...) {
49346       {
49347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49348       };
49349     }
49350   }
49351   jresult = result;
49352   return jresult;
49353 }
49354
49355
49356 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
49357   unsigned long jresult ;
49358   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49359   std::size_t result;
49360
49361   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49362   {
49363     try {
49364       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
49365     } catch (std::out_of_range& e) {
49366       {
49367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49368       };
49369     } catch (std::exception& e) {
49370       {
49371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49372       };
49373     } catch (...) {
49374       {
49375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49376       };
49377     }
49378   }
49379   jresult = (unsigned long)result;
49380   return jresult;
49381 }
49382
49383
49384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
49385   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49386   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49387
49388   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49389   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49390   {
49391     try {
49392       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
49393     } catch (std::out_of_range& e) {
49394       {
49395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49396       };
49397     } catch (std::exception& e) {
49398       {
49399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49400       };
49401     } catch (...) {
49402       {
49403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49404       };
49405     }
49406   }
49407 }
49408
49409
49410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
49411   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49412   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49413
49414   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49415   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49416   {
49417     try {
49418       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
49419     } catch (std::out_of_range& e) {
49420       {
49421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49422       };
49423     } catch (std::exception& e) {
49424       {
49425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49426       };
49427     } catch (...) {
49428       {
49429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49430       };
49431     }
49432   }
49433 }
49434
49435
49436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
49437   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49438   Dali::PropertyNotification *arg2 = 0 ;
49439
49440   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49441   arg2 = (Dali::PropertyNotification *)jarg2;
49442   if (!arg2) {
49443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
49444     return ;
49445   }
49446   {
49447     try {
49448       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
49449     } catch (std::out_of_range& e) {
49450       {
49451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49452       };
49453     } catch (std::exception& e) {
49454       {
49455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49456       };
49457     } catch (...) {
49458       {
49459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49460       };
49461     }
49462   }
49463 }
49464
49465
49466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
49467   void * jresult ;
49468   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
49469
49470   {
49471     try {
49472       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
49473     } catch (std::out_of_range& e) {
49474       {
49475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49476       };
49477     } catch (std::exception& e) {
49478       {
49479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49480       };
49481     } catch (...) {
49482       {
49483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49484       };
49485     }
49486   }
49487   jresult = (void *)result;
49488   return jresult;
49489 }
49490
49491
49492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
49493   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49494
49495   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49496   {
49497     try {
49498       delete arg1;
49499     } catch (std::out_of_range& e) {
49500       {
49501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49502       };
49503     } catch (std::exception& e) {
49504       {
49505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49506       };
49507     } catch (...) {
49508       {
49509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49510       };
49511     }
49512   }
49513 }
49514
49515
49516 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
49517   unsigned int jresult ;
49518   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49519   bool result;
49520
49521   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49522   {
49523     try {
49524       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
49525     } catch (std::out_of_range& e) {
49526       {
49527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49528       };
49529     } catch (std::exception& e) {
49530       {
49531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49532       };
49533     } catch (...) {
49534       {
49535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49536       };
49537     }
49538   }
49539   jresult = result;
49540   return jresult;
49541 }
49542
49543
49544 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
49545   unsigned long jresult ;
49546   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49547   std::size_t result;
49548
49549   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49550   {
49551     try {
49552       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
49553     } catch (std::out_of_range& e) {
49554       {
49555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49556       };
49557     } catch (std::exception& e) {
49558       {
49559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49560       };
49561     } catch (...) {
49562       {
49563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49564       };
49565     }
49566   }
49567   jresult = (unsigned long)result;
49568   return jresult;
49569 }
49570
49571
49572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
49573   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49574   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49575
49576   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49577   arg2 = (void (*)(Dali::Image))jarg2;
49578   {
49579     try {
49580       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
49581     } catch (std::out_of_range& e) {
49582       {
49583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49584       };
49585     } catch (std::exception& e) {
49586       {
49587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49588       };
49589     } catch (...) {
49590       {
49591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49592       };
49593     }
49594   }
49595 }
49596
49597
49598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
49599   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49600   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49601
49602   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49603   arg2 = (void (*)(Dali::Image))jarg2;
49604   {
49605     try {
49606       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
49607     } catch (std::out_of_range& e) {
49608       {
49609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49610       };
49611     } catch (std::exception& e) {
49612       {
49613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49614       };
49615     } catch (...) {
49616       {
49617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49618       };
49619     }
49620   }
49621 }
49622
49623
49624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
49625   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49626   Dali::Image arg2 ;
49627   Dali::Image *argp2 ;
49628
49629   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49630   argp2 = (Dali::Image *)jarg2;
49631   if (!argp2) {
49632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
49633     return ;
49634   }
49635   arg2 = *argp2;
49636   {
49637     try {
49638       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
49639     } catch (std::out_of_range& e) {
49640       {
49641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49642       };
49643     } catch (std::exception& e) {
49644       {
49645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49646       };
49647     } catch (...) {
49648       {
49649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49650       };
49651     }
49652   }
49653 }
49654
49655
49656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
49657   void * jresult ;
49658   Dali::Signal< void (Dali::Image) > *result = 0 ;
49659
49660   {
49661     try {
49662       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
49663     } catch (std::out_of_range& e) {
49664       {
49665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49666       };
49667     } catch (std::exception& e) {
49668       {
49669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49670       };
49671     } catch (...) {
49672       {
49673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49674       };
49675     }
49676   }
49677   jresult = (void *)result;
49678   return jresult;
49679 }
49680
49681
49682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
49683   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49684
49685   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49686   {
49687     try {
49688       delete arg1;
49689     } catch (std::out_of_range& e) {
49690       {
49691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49692       };
49693     } catch (std::exception& e) {
49694       {
49695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49696       };
49697     } catch (...) {
49698       {
49699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49700       };
49701     }
49702   }
49703 }
49704
49705
49706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
49707   void * jresult ;
49708   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
49709
49710   {
49711     try {
49712       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
49713     } catch (std::out_of_range& e) {
49714       {
49715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49716       };
49717     } catch (std::exception& e) {
49718       {
49719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49720       };
49721     } catch (...) {
49722       {
49723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49724       };
49725     }
49726   }
49727   jresult = (void *)result;
49728   return jresult;
49729 }
49730
49731
49732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
49733   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
49734
49735   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
49736   {
49737     try {
49738       delete arg1;
49739     } catch (std::out_of_range& e) {
49740       {
49741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49742       };
49743     } catch (std::exception& e) {
49744       {
49745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49746       };
49747     } catch (...) {
49748       {
49749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49750       };
49751     }
49752   }
49753 }
49754
49755
49756 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
49757   unsigned int jresult ;
49758   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49759   bool result;
49760
49761   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49762   {
49763     try {
49764       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);
49765     } catch (std::out_of_range& e) {
49766       {
49767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49768       };
49769     } catch (std::exception& e) {
49770       {
49771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49772       };
49773     } catch (...) {
49774       {
49775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49776       };
49777     }
49778   }
49779   jresult = result;
49780   return jresult;
49781 }
49782
49783
49784 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
49785   unsigned long jresult ;
49786   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49787   std::size_t result;
49788
49789   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49790   {
49791     try {
49792       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);
49793     } catch (std::out_of_range& e) {
49794       {
49795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49796       };
49797     } catch (std::exception& e) {
49798       {
49799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49800       };
49801     } catch (...) {
49802       {
49803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49804       };
49805     }
49806   }
49807   jresult = (unsigned long)result;
49808   return jresult;
49809 }
49810
49811
49812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
49813   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49814   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
49815
49816   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49817   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
49818   {
49819     try {
49820       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49821     } catch (std::out_of_range& e) {
49822       {
49823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49824       };
49825     } catch (std::exception& e) {
49826       {
49827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49828       };
49829     } catch (...) {
49830       {
49831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49832       };
49833     }
49834   }
49835 }
49836
49837
49838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
49839   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49840   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
49841
49842   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49843   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
49844   {
49845     try {
49846       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
49847     } catch (std::out_of_range& e) {
49848       {
49849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49850       };
49851     } catch (std::exception& e) {
49852       {
49853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49854       };
49855     } catch (...) {
49856       {
49857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49858       };
49859     }
49860   }
49861 }
49862
49863
49864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
49865   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49866   Dali::Actor arg2 ;
49867   Dali::LongPressGesture *arg3 = 0 ;
49868   Dali::Actor *argp2 ;
49869
49870   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49871   argp2 = (Dali::Actor *)jarg2;
49872   if (!argp2) {
49873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49874     return ;
49875   }
49876   arg2 = *argp2;
49877   arg3 = (Dali::LongPressGesture *)jarg3;
49878   if (!arg3) {
49879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
49880     return ;
49881   }
49882   {
49883     try {
49884       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
49885     } catch (std::out_of_range& e) {
49886       {
49887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49888       };
49889     } catch (std::exception& e) {
49890       {
49891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49892       };
49893     } catch (...) {
49894       {
49895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49896       };
49897     }
49898   }
49899 }
49900
49901
49902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
49903   void * jresult ;
49904   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
49905
49906   {
49907     try {
49908       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
49909     } catch (std::out_of_range& e) {
49910       {
49911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49912       };
49913     } catch (std::exception& e) {
49914       {
49915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49916       };
49917     } catch (...) {
49918       {
49919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49920       };
49921     }
49922   }
49923   jresult = (void *)result;
49924   return jresult;
49925 }
49926
49927
49928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
49929   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49930
49931   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49932   {
49933     try {
49934       delete arg1;
49935     } catch (std::out_of_range& e) {
49936       {
49937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49938       };
49939     } catch (std::exception& e) {
49940       {
49941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49942       };
49943     } catch (...) {
49944       {
49945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49946       };
49947     }
49948   }
49949 }
49950
49951
49952 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
49953   unsigned int jresult ;
49954   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
49955   bool result;
49956
49957   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
49958   {
49959     try {
49960       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);
49961     } catch (std::out_of_range& e) {
49962       {
49963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49964       };
49965     } catch (std::exception& e) {
49966       {
49967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49968       };
49969     } catch (...) {
49970       {
49971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49972       };
49973     }
49974   }
49975   jresult = result;
49976   return jresult;
49977 }
49978
49979
49980 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
49981   unsigned long jresult ;
49982   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
49983   std::size_t result;
49984
49985   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
49986   {
49987     try {
49988       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);
49989     } catch (std::out_of_range& e) {
49990       {
49991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49992       };
49993     } catch (std::exception& e) {
49994       {
49995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49996       };
49997     } catch (...) {
49998       {
49999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50000       };
50001     }
50002   }
50003   jresult = (unsigned long)result;
50004   return jresult;
50005 }
50006
50007
50008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
50009   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50010   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
50011
50012   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50013   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
50014   {
50015     try {
50016       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50017     } catch (std::out_of_range& e) {
50018       {
50019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50020       };
50021     } catch (std::exception& e) {
50022       {
50023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50024       };
50025     } catch (...) {
50026       {
50027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50028       };
50029     }
50030   }
50031 }
50032
50033
50034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
50035   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50036   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
50037
50038   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50039   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
50040   {
50041     try {
50042       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50043     } catch (std::out_of_range& e) {
50044       {
50045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50046       };
50047     } catch (std::exception& e) {
50048       {
50049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50050       };
50051     } catch (...) {
50052       {
50053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50054       };
50055     }
50056   }
50057 }
50058
50059
50060 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50061   unsigned int jresult ;
50062   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50063   Dali::Actor arg2 ;
50064   Dali::TouchData *arg3 = 0 ;
50065   Dali::Actor *argp2 ;
50066   bool result;
50067
50068   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50069   argp2 = (Dali::Actor *)jarg2;
50070   if (!argp2) {
50071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50072     return 0;
50073   }
50074   arg2 = *argp2;
50075   arg3 = (Dali::TouchData *)jarg3;
50076   if (!arg3) {
50077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
50078     return 0;
50079   }
50080   {
50081     try {
50082       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
50083     } catch (std::out_of_range& e) {
50084       {
50085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50086       };
50087     } catch (std::exception& e) {
50088       {
50089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50090       };
50091     } catch (...) {
50092       {
50093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50094       };
50095     }
50096   }
50097   jresult = result;
50098   return jresult;
50099 }
50100
50101
50102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
50103   void * jresult ;
50104   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
50105
50106   {
50107     try {
50108       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
50109     } catch (std::out_of_range& e) {
50110       {
50111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50112       };
50113     } catch (std::exception& e) {
50114       {
50115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50116       };
50117     } catch (...) {
50118       {
50119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50120       };
50121     }
50122   }
50123   jresult = (void *)result;
50124   return jresult;
50125 }
50126
50127
50128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
50129   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50130
50131   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50132   {
50133     try {
50134       delete arg1;
50135     } catch (std::out_of_range& e) {
50136       {
50137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50138       };
50139     } catch (std::exception& e) {
50140       {
50141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50142       };
50143     } catch (...) {
50144       {
50145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50146       };
50147     }
50148   }
50149 }
50150
50151
50152 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
50153   unsigned int jresult ;
50154   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50155   bool result;
50156
50157   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50158   {
50159     try {
50160       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);
50161     } catch (std::out_of_range& e) {
50162       {
50163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50164       };
50165     } catch (std::exception& e) {
50166       {
50167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50168       };
50169     } catch (...) {
50170       {
50171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50172       };
50173     }
50174   }
50175   jresult = result;
50176   return jresult;
50177 }
50178
50179
50180 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
50181   unsigned long jresult ;
50182   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50183   std::size_t result;
50184
50185   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50186   {
50187     try {
50188       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);
50189     } catch (std::out_of_range& e) {
50190       {
50191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50192       };
50193     } catch (std::exception& e) {
50194       {
50195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50196       };
50197     } catch (...) {
50198       {
50199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50200       };
50201     }
50202   }
50203   jresult = (unsigned long)result;
50204   return jresult;
50205 }
50206
50207
50208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
50209   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50210   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50211
50212   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50213   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50214   {
50215     try {
50216       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50217     } catch (std::out_of_range& e) {
50218       {
50219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50220       };
50221     } catch (std::exception& e) {
50222       {
50223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50224       };
50225     } catch (...) {
50226       {
50227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50228       };
50229     }
50230   }
50231 }
50232
50233
50234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
50235   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50236   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50237
50238   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50239   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50240   {
50241     try {
50242       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50243     } catch (std::out_of_range& e) {
50244       {
50245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50246       };
50247     } catch (std::exception& e) {
50248       {
50249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50250       };
50251     } catch (...) {
50252       {
50253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50254       };
50255     }
50256   }
50257 }
50258
50259
50260 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50261   unsigned int jresult ;
50262   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50263   Dali::Actor arg2 ;
50264   Dali::HoverEvent *arg3 = 0 ;
50265   Dali::Actor *argp2 ;
50266   bool result;
50267
50268   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50269   argp2 = (Dali::Actor *)jarg2;
50270   if (!argp2) {
50271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50272     return 0;
50273   }
50274   arg2 = *argp2;
50275   arg3 = (Dali::HoverEvent *)jarg3;
50276   if (!arg3) {
50277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
50278     return 0;
50279   }
50280   {
50281     try {
50282       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
50283     } catch (std::out_of_range& e) {
50284       {
50285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50286       };
50287     } catch (std::exception& e) {
50288       {
50289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50290       };
50291     } catch (...) {
50292       {
50293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50294       };
50295     }
50296   }
50297   jresult = result;
50298   return jresult;
50299 }
50300
50301
50302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
50303   void * jresult ;
50304   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
50305
50306   {
50307     try {
50308       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
50309     } catch (std::out_of_range& e) {
50310       {
50311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50312       };
50313     } catch (std::exception& e) {
50314       {
50315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50316       };
50317     } catch (...) {
50318       {
50319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50320       };
50321     }
50322   }
50323   jresult = (void *)result;
50324   return jresult;
50325 }
50326
50327
50328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
50329   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50330
50331   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50332   {
50333     try {
50334       delete arg1;
50335     } catch (std::out_of_range& e) {
50336       {
50337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50338       };
50339     } catch (std::exception& e) {
50340       {
50341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50342       };
50343     } catch (...) {
50344       {
50345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50346       };
50347     }
50348   }
50349 }
50350
50351
50352 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
50353   unsigned int jresult ;
50354   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50355   bool result;
50356
50357   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50358   {
50359     try {
50360       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);
50361     } catch (std::out_of_range& e) {
50362       {
50363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50364       };
50365     } catch (std::exception& e) {
50366       {
50367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50368       };
50369     } catch (...) {
50370       {
50371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50372       };
50373     }
50374   }
50375   jresult = result;
50376   return jresult;
50377 }
50378
50379
50380 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
50381   unsigned long jresult ;
50382   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50383   std::size_t result;
50384
50385   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50386   {
50387     try {
50388       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);
50389     } catch (std::out_of_range& e) {
50390       {
50391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50392       };
50393     } catch (std::exception& e) {
50394       {
50395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50396       };
50397     } catch (...) {
50398       {
50399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50400       };
50401     }
50402   }
50403   jresult = (unsigned long)result;
50404   return jresult;
50405 }
50406
50407
50408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
50409   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50410   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50411
50412   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50413   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50414   {
50415     try {
50416       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50417     } catch (std::out_of_range& e) {
50418       {
50419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50420       };
50421     } catch (std::exception& e) {
50422       {
50423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50424       };
50425     } catch (...) {
50426       {
50427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50428       };
50429     }
50430   }
50431 }
50432
50433
50434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
50435   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50436   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50437
50438   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50439   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50440   {
50441     try {
50442       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50443     } catch (std::out_of_range& e) {
50444       {
50445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50446       };
50447     } catch (std::exception& e) {
50448       {
50449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50450       };
50451     } catch (...) {
50452       {
50453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50454       };
50455     }
50456   }
50457 }
50458
50459
50460 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50461   unsigned int jresult ;
50462   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50463   Dali::Actor arg2 ;
50464   Dali::WheelEvent *arg3 = 0 ;
50465   Dali::Actor *argp2 ;
50466   bool result;
50467
50468   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50469   argp2 = (Dali::Actor *)jarg2;
50470   if (!argp2) {
50471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50472     return 0;
50473   }
50474   arg2 = *argp2;
50475   arg3 = (Dali::WheelEvent *)jarg3;
50476   if (!arg3) {
50477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
50478     return 0;
50479   }
50480   {
50481     try {
50482       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
50483     } catch (std::out_of_range& e) {
50484       {
50485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50486       };
50487     } catch (std::exception& e) {
50488       {
50489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50490       };
50491     } catch (...) {
50492       {
50493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50494       };
50495     }
50496   }
50497   jresult = result;
50498   return jresult;
50499 }
50500
50501
50502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
50503   void * jresult ;
50504   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
50505
50506   {
50507     try {
50508       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
50509     } catch (std::out_of_range& e) {
50510       {
50511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50512       };
50513     } catch (std::exception& e) {
50514       {
50515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50516       };
50517     } catch (...) {
50518       {
50519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50520       };
50521     }
50522   }
50523   jresult = (void *)result;
50524   return jresult;
50525 }
50526
50527
50528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
50529   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50530
50531   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50532   {
50533     try {
50534       delete arg1;
50535     } catch (std::out_of_range& e) {
50536       {
50537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50538       };
50539     } catch (std::exception& e) {
50540       {
50541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50542       };
50543     } catch (...) {
50544       {
50545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50546       };
50547     }
50548   }
50549 }
50550
50551
50552 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
50553   unsigned int jresult ;
50554   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50555   bool result;
50556
50557   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50558   {
50559     try {
50560       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
50561     } catch (std::out_of_range& e) {
50562       {
50563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50564       };
50565     } catch (std::exception& e) {
50566       {
50567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50568       };
50569     } catch (...) {
50570       {
50571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50572       };
50573     }
50574   }
50575   jresult = result;
50576   return jresult;
50577 }
50578
50579
50580 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
50581   unsigned long jresult ;
50582   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50583   std::size_t result;
50584
50585   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50586   {
50587     try {
50588       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
50589     } catch (std::out_of_range& e) {
50590       {
50591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50592       };
50593     } catch (std::exception& e) {
50594       {
50595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50596       };
50597     } catch (...) {
50598       {
50599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50600       };
50601     }
50602   }
50603   jresult = (unsigned long)result;
50604   return jresult;
50605 }
50606
50607
50608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
50609   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50610   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50611
50612   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50613   arg2 = (void (*)(Dali::Actor))jarg2;
50614   {
50615     try {
50616       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
50617     } catch (std::out_of_range& e) {
50618       {
50619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50620       };
50621     } catch (std::exception& e) {
50622       {
50623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50624       };
50625     } catch (...) {
50626       {
50627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50628       };
50629     }
50630   }
50631 }
50632
50633
50634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
50635   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50636   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50637
50638   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50639   arg2 = (void (*)(Dali::Actor))jarg2;
50640   {
50641     try {
50642       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
50643     } catch (std::out_of_range& e) {
50644       {
50645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50646       };
50647     } catch (std::exception& e) {
50648       {
50649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50650       };
50651     } catch (...) {
50652       {
50653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50654       };
50655     }
50656   }
50657 }
50658
50659
50660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
50661   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50662   Dali::Actor arg2 ;
50663   Dali::Actor *argp2 ;
50664
50665   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50666   argp2 = (Dali::Actor *)jarg2;
50667   if (!argp2) {
50668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50669     return ;
50670   }
50671   arg2 = *argp2;
50672   {
50673     try {
50674       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
50675     } catch (std::out_of_range& e) {
50676       {
50677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50678       };
50679     } catch (std::exception& e) {
50680       {
50681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50682       };
50683     } catch (...) {
50684       {
50685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50686       };
50687     }
50688   }
50689 }
50690
50691
50692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
50693   void * jresult ;
50694   Dali::Signal< void (Dali::Actor) > *result = 0 ;
50695
50696   {
50697     try {
50698       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
50699     } catch (std::out_of_range& e) {
50700       {
50701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50702       };
50703     } catch (std::exception& e) {
50704       {
50705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50706       };
50707     } catch (...) {
50708       {
50709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50710       };
50711     }
50712   }
50713   jresult = (void *)result;
50714   return jresult;
50715 }
50716
50717
50718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
50719   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50720
50721   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50722   {
50723     try {
50724       delete arg1;
50725     } catch (std::out_of_range& e) {
50726       {
50727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50728       };
50729     } catch (std::exception& e) {
50730       {
50731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50732       };
50733     } catch (...) {
50734       {
50735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50736       };
50737     }
50738   }
50739 }
50740
50741
50742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
50743   unsigned int jresult ;
50744   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50745   bool result;
50746
50747   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50748   {
50749     try {
50750       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
50751     } catch (std::out_of_range& e) {
50752       {
50753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50754       };
50755     } catch (std::exception& e) {
50756       {
50757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50758       };
50759     } catch (...) {
50760       {
50761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50762       };
50763     }
50764   }
50765   jresult = result;
50766   return jresult;
50767 }
50768
50769
50770 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
50771   unsigned long jresult ;
50772   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50773   std::size_t result;
50774
50775   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50776   {
50777     try {
50778       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
50779     } catch (std::out_of_range& e) {
50780       {
50781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50782       };
50783     } catch (std::exception& e) {
50784       {
50785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50786       };
50787     } catch (...) {
50788       {
50789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50790       };
50791     }
50792   }
50793   jresult = (unsigned long)result;
50794   return jresult;
50795 }
50796
50797
50798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
50799   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50800   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
50801
50802   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50803   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
50804   {
50805     try {
50806       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50807     } catch (std::out_of_range& e) {
50808       {
50809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50810       };
50811     } catch (std::exception& e) {
50812       {
50813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50814       };
50815     } catch (...) {
50816       {
50817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50818       };
50819     }
50820   }
50821 }
50822
50823
50824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
50825   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50826   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
50827
50828   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50829   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
50830   {
50831     try {
50832       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50833     } catch (std::out_of_range& e) {
50834       {
50835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50836       };
50837     } catch (std::exception& e) {
50838       {
50839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50840       };
50841     } catch (...) {
50842       {
50843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50844       };
50845     }
50846   }
50847 }
50848
50849
50850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
50851   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50852   Dali::KeyEvent *arg2 = 0 ;
50853
50854   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50855   arg2 = (Dali::KeyEvent *)jarg2;
50856   if (!arg2) {
50857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
50858     return ;
50859   }
50860   {
50861     try {
50862       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
50863     } catch (std::out_of_range& e) {
50864       {
50865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50866       };
50867     } catch (std::exception& e) {
50868       {
50869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50870       };
50871     } catch (...) {
50872       {
50873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50874       };
50875     }
50876   }
50877 }
50878
50879
50880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
50881   void * jresult ;
50882   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
50883
50884   {
50885     try {
50886       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
50887     } catch (std::out_of_range& e) {
50888       {
50889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50890       };
50891     } catch (std::exception& e) {
50892       {
50893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50894       };
50895     } catch (...) {
50896       {
50897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50898       };
50899     }
50900   }
50901   jresult = (void *)result;
50902   return jresult;
50903 }
50904
50905
50906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
50907   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50908
50909   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50910   {
50911     try {
50912       delete arg1;
50913     } catch (std::out_of_range& e) {
50914       {
50915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50916       };
50917     } catch (std::exception& e) {
50918       {
50919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50920       };
50921     } catch (...) {
50922       {
50923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50924       };
50925     }
50926   }
50927 }
50928
50929
50930 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
50931   unsigned int jresult ;
50932   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
50933   bool result;
50934
50935   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
50936   {
50937     try {
50938       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
50939     } catch (std::out_of_range& e) {
50940       {
50941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50942       };
50943     } catch (std::exception& e) {
50944       {
50945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50946       };
50947     } catch (...) {
50948       {
50949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50950       };
50951     }
50952   }
50953   jresult = result;
50954   return jresult;
50955 }
50956
50957
50958 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
50959   unsigned long jresult ;
50960   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
50961   std::size_t result;
50962
50963   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
50964   {
50965     try {
50966       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
50967     } catch (std::out_of_range& e) {
50968       {
50969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50970       };
50971     } catch (std::exception& e) {
50972       {
50973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50974       };
50975     } catch (...) {
50976       {
50977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50978       };
50979     }
50980   }
50981   jresult = (unsigned long)result;
50982   return jresult;
50983 }
50984
50985
50986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
50987   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
50988   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
50989
50990   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
50991   arg2 = (void (*)(Dali::TouchData const &))jarg2;
50992   {
50993     try {
50994       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50995     } catch (std::out_of_range& e) {
50996       {
50997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50998       };
50999     } catch (std::exception& e) {
51000       {
51001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51002       };
51003     } catch (...) {
51004       {
51005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51006       };
51007     }
51008   }
51009 }
51010
51011
51012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
51013   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51014   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
51015
51016   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51017   arg2 = (void (*)(Dali::TouchData const &))jarg2;
51018   {
51019     try {
51020       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51021     } catch (std::out_of_range& e) {
51022       {
51023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51024       };
51025     } catch (std::exception& e) {
51026       {
51027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51028       };
51029     } catch (...) {
51030       {
51031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51032       };
51033     }
51034   }
51035 }
51036
51037
51038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
51039   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51040   Dali::TouchData *arg2 = 0 ;
51041
51042   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51043   arg2 = (Dali::TouchData *)jarg2;
51044   if (!arg2) {
51045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
51046     return ;
51047   }
51048   {
51049     try {
51050       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
51051     } catch (std::out_of_range& e) {
51052       {
51053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51054       };
51055     } catch (std::exception& e) {
51056       {
51057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51058       };
51059     } catch (...) {
51060       {
51061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51062       };
51063     }
51064   }
51065 }
51066
51067
51068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
51069   void * jresult ;
51070   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
51071
51072   {
51073     try {
51074       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
51075     } catch (std::out_of_range& e) {
51076       {
51077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51078       };
51079     } catch (std::exception& e) {
51080       {
51081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51082       };
51083     } catch (...) {
51084       {
51085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51086       };
51087     }
51088   }
51089   jresult = (void *)result;
51090   return jresult;
51091 }
51092
51093
51094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
51095   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51096
51097   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51098   {
51099     try {
51100       delete arg1;
51101     } catch (std::out_of_range& e) {
51102       {
51103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51104       };
51105     } catch (std::exception& e) {
51106       {
51107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51108       };
51109     } catch (...) {
51110       {
51111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51112       };
51113     }
51114   }
51115 }
51116
51117
51118 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
51119   unsigned int jresult ;
51120   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51121   bool result;
51122
51123   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51124   {
51125     try {
51126       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
51127     } catch (std::out_of_range& e) {
51128       {
51129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51130       };
51131     } catch (std::exception& e) {
51132       {
51133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51134       };
51135     } catch (...) {
51136       {
51137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51138       };
51139     }
51140   }
51141   jresult = result;
51142   return jresult;
51143 }
51144
51145
51146 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
51147   unsigned long jresult ;
51148   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51149   std::size_t result;
51150
51151   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51152   {
51153     try {
51154       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
51155     } catch (std::out_of_range& e) {
51156       {
51157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51158       };
51159     } catch (std::exception& e) {
51160       {
51161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51162       };
51163     } catch (...) {
51164       {
51165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51166       };
51167     }
51168   }
51169   jresult = (unsigned long)result;
51170   return jresult;
51171 }
51172
51173
51174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
51175   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51176   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51177
51178   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51179   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51180   {
51181     try {
51182       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51183     } catch (std::out_of_range& e) {
51184       {
51185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51186       };
51187     } catch (std::exception& e) {
51188       {
51189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51190       };
51191     } catch (...) {
51192       {
51193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51194       };
51195     }
51196   }
51197 }
51198
51199
51200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
51201   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51202   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51203
51204   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51205   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51206   {
51207     try {
51208       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51209     } catch (std::out_of_range& e) {
51210       {
51211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51212       };
51213     } catch (std::exception& e) {
51214       {
51215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51216       };
51217     } catch (...) {
51218       {
51219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51220       };
51221     }
51222   }
51223 }
51224
51225
51226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
51227   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51228   Dali::WheelEvent *arg2 = 0 ;
51229
51230   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51231   arg2 = (Dali::WheelEvent *)jarg2;
51232   if (!arg2) {
51233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
51234     return ;
51235   }
51236   {
51237     try {
51238       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
51239     } catch (std::out_of_range& e) {
51240       {
51241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51242       };
51243     } catch (std::exception& e) {
51244       {
51245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51246       };
51247     } catch (...) {
51248       {
51249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51250       };
51251     }
51252   }
51253 }
51254
51255
51256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
51257   void * jresult ;
51258   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
51259
51260   {
51261     try {
51262       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
51263     } catch (std::out_of_range& e) {
51264       {
51265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51266       };
51267     } catch (std::exception& e) {
51268       {
51269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51270       };
51271     } catch (...) {
51272       {
51273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51274       };
51275     }
51276   }
51277   jresult = (void *)result;
51278   return jresult;
51279 }
51280
51281
51282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
51283   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51284
51285   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51286   {
51287     try {
51288       delete arg1;
51289     } catch (std::out_of_range& e) {
51290       {
51291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51292       };
51293     } catch (std::exception& e) {
51294       {
51295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51296       };
51297     } catch (...) {
51298       {
51299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51300       };
51301     }
51302   }
51303 }
51304
51305
51306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
51307   void * jresult ;
51308   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51309
51310   {
51311     try {
51312       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
51313     } catch (std::out_of_range& e) {
51314       {
51315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51316       };
51317     } catch (std::exception& e) {
51318       {
51319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51320       };
51321     } catch (...) {
51322       {
51323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51324       };
51325     }
51326   }
51327   jresult = (void *)result;
51328   return jresult;
51329 }
51330
51331
51332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
51333   void * jresult ;
51334   Dali::Radian arg1 ;
51335   Dali::Radian arg2 ;
51336   Dali::Radian *argp1 ;
51337   Dali::Radian *argp2 ;
51338   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51339
51340   argp1 = (Dali::Radian *)jarg1;
51341   if (!argp1) {
51342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51343     return 0;
51344   }
51345   arg1 = *argp1;
51346   argp2 = (Dali::Radian *)jarg2;
51347   if (!argp2) {
51348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51349     return 0;
51350   }
51351   arg2 = *argp2;
51352   {
51353     try {
51354       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
51355     } catch (std::out_of_range& e) {
51356       {
51357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51358       };
51359     } catch (std::exception& e) {
51360       {
51361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51362       };
51363     } catch (...) {
51364       {
51365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51366       };
51367     }
51368   }
51369   jresult = (void *)result;
51370   return jresult;
51371 }
51372
51373
51374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
51375   void * jresult ;
51376   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
51377   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51378
51379   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51380   if (!arg1) {
51381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
51382     return 0;
51383   }
51384   {
51385     try {
51386       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
51387     } catch (std::out_of_range& e) {
51388       {
51389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51390       };
51391     } catch (std::exception& e) {
51392       {
51393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51394       };
51395     } catch (...) {
51396       {
51397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51398       };
51399     }
51400   }
51401   jresult = (void *)result;
51402   return jresult;
51403 }
51404
51405
51406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
51407   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51408   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51409
51410   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51411   arg2 = (Dali::Radian *)jarg2;
51412   if (arg1) (arg1)->first = *arg2;
51413 }
51414
51415
51416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
51417   void * jresult ;
51418   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51419   Dali::Radian *result = 0 ;
51420
51421   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51422   result = (Dali::Radian *)& ((arg1)->first);
51423   jresult = (void *)result;
51424   return jresult;
51425 }
51426
51427
51428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
51429   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51430   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51431
51432   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51433   arg2 = (Dali::Radian *)jarg2;
51434   if (arg1) (arg1)->second = *arg2;
51435 }
51436
51437
51438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
51439   void * jresult ;
51440   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51441   Dali::Radian *result = 0 ;
51442
51443   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51444   result = (Dali::Radian *)& ((arg1)->second);
51445   jresult = (void *)result;
51446   return jresult;
51447 }
51448
51449
51450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
51451   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51452
51453   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51454   {
51455     try {
51456       delete arg1;
51457     } catch (std::out_of_range& e) {
51458       {
51459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51460       };
51461     } catch (std::exception& e) {
51462       {
51463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51464       };
51465     } catch (...) {
51466       {
51467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51468       };
51469     }
51470   }
51471 }
51472
51473
51474 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
51475   unsigned int jresult ;
51476   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51477   bool result;
51478
51479   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51480   {
51481     try {
51482       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);
51483     } catch (std::out_of_range& e) {
51484       {
51485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51486       };
51487     } catch (std::exception& e) {
51488       {
51489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51490       };
51491     } catch (...) {
51492       {
51493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51494       };
51495     }
51496   }
51497   jresult = result;
51498   return jresult;
51499 }
51500
51501
51502 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51503   unsigned long jresult ;
51504   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51505   std::size_t result;
51506
51507   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51508   {
51509     try {
51510       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);
51511     } catch (std::out_of_range& e) {
51512       {
51513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51514       };
51515     } catch (std::exception& e) {
51516       {
51517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51518       };
51519     } catch (...) {
51520       {
51521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51522       };
51523     }
51524   }
51525   jresult = (unsigned long)result;
51526   return jresult;
51527 }
51528
51529
51530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51531   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51532   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51533
51534   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51535   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51536   {
51537     try {
51538       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51539     } catch (std::out_of_range& e) {
51540       {
51541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51542       };
51543     } catch (std::exception& e) {
51544       {
51545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51546       };
51547     } catch (...) {
51548       {
51549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51550       };
51551     }
51552   }
51553 }
51554
51555
51556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51557   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51558   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51559
51560   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51561   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51562   {
51563     try {
51564       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51565     } catch (std::out_of_range& e) {
51566       {
51567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51568       };
51569     } catch (std::exception& e) {
51570       {
51571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51572       };
51573     } catch (...) {
51574       {
51575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51576       };
51577     }
51578   }
51579 }
51580
51581
51582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51583   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51584   Dali::Actor arg2 ;
51585   Dali::PanGesture *arg3 = 0 ;
51586   Dali::Actor *argp2 ;
51587
51588   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51589   argp2 = (Dali::Actor *)jarg2;
51590   if (!argp2) {
51591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51592     return ;
51593   }
51594   arg2 = *argp2;
51595   arg3 = (Dali::PanGesture *)jarg3;
51596   if (!arg3) {
51597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
51598     return ;
51599   }
51600   {
51601     try {
51602       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
51603     } catch (std::out_of_range& e) {
51604       {
51605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51606       };
51607     } catch (std::exception& e) {
51608       {
51609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51610       };
51611     } catch (...) {
51612       {
51613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51614       };
51615     }
51616   }
51617 }
51618
51619
51620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
51621   void * jresult ;
51622   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
51623
51624   {
51625     try {
51626       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
51627     } catch (std::out_of_range& e) {
51628       {
51629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51630       };
51631     } catch (std::exception& e) {
51632       {
51633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51634       };
51635     } catch (...) {
51636       {
51637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51638       };
51639     }
51640   }
51641   jresult = (void *)result;
51642   return jresult;
51643 }
51644
51645
51646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
51647   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51648
51649   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51650   {
51651     try {
51652       delete arg1;
51653     } catch (std::out_of_range& e) {
51654       {
51655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51656       };
51657     } catch (std::exception& e) {
51658       {
51659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51660       };
51661     } catch (...) {
51662       {
51663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51664       };
51665     }
51666   }
51667 }
51668
51669
51670 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
51671   unsigned int jresult ;
51672   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51673   bool result;
51674
51675   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51676   {
51677     try {
51678       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);
51679     } catch (std::out_of_range& e) {
51680       {
51681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51682       };
51683     } catch (std::exception& e) {
51684       {
51685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51686       };
51687     } catch (...) {
51688       {
51689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51690       };
51691     }
51692   }
51693   jresult = result;
51694   return jresult;
51695 }
51696
51697
51698 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51699   unsigned long jresult ;
51700   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51701   std::size_t result;
51702
51703   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51704   {
51705     try {
51706       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);
51707     } catch (std::out_of_range& e) {
51708       {
51709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51710       };
51711     } catch (std::exception& e) {
51712       {
51713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51714       };
51715     } catch (...) {
51716       {
51717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51718       };
51719     }
51720   }
51721   jresult = (unsigned long)result;
51722   return jresult;
51723 }
51724
51725
51726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51727   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51728   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
51729
51730   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51731   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
51732   {
51733     try {
51734       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51735     } catch (std::out_of_range& e) {
51736       {
51737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51738       };
51739     } catch (std::exception& e) {
51740       {
51741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51742       };
51743     } catch (...) {
51744       {
51745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51746       };
51747     }
51748   }
51749 }
51750
51751
51752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51753   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51754   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
51755
51756   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51757   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
51758   {
51759     try {
51760       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51761     } catch (std::out_of_range& e) {
51762       {
51763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51764       };
51765     } catch (std::exception& e) {
51766       {
51767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51768       };
51769     } catch (...) {
51770       {
51771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51772       };
51773     }
51774   }
51775 }
51776
51777
51778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51779   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51780   Dali::Actor arg2 ;
51781   Dali::PinchGesture *arg3 = 0 ;
51782   Dali::Actor *argp2 ;
51783
51784   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51785   argp2 = (Dali::Actor *)jarg2;
51786   if (!argp2) {
51787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51788     return ;
51789   }
51790   arg2 = *argp2;
51791   arg3 = (Dali::PinchGesture *)jarg3;
51792   if (!arg3) {
51793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
51794     return ;
51795   }
51796   {
51797     try {
51798       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
51799     } catch (std::out_of_range& e) {
51800       {
51801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51802       };
51803     } catch (std::exception& e) {
51804       {
51805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51806       };
51807     } catch (...) {
51808       {
51809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51810       };
51811     }
51812   }
51813 }
51814
51815
51816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
51817   void * jresult ;
51818   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
51819
51820   {
51821     try {
51822       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
51823     } catch (std::out_of_range& e) {
51824       {
51825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51826       };
51827     } catch (std::exception& e) {
51828       {
51829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51830       };
51831     } catch (...) {
51832       {
51833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51834       };
51835     }
51836   }
51837   jresult = (void *)result;
51838   return jresult;
51839 }
51840
51841
51842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
51843   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51844
51845   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51846   {
51847     try {
51848       delete arg1;
51849     } catch (std::out_of_range& e) {
51850       {
51851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51852       };
51853     } catch (std::exception& e) {
51854       {
51855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51856       };
51857     } catch (...) {
51858       {
51859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51860       };
51861     }
51862   }
51863 }
51864
51865
51866 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
51867   unsigned int jresult ;
51868   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51869   bool result;
51870
51871   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51872   {
51873     try {
51874       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);
51875     } catch (std::out_of_range& e) {
51876       {
51877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51878       };
51879     } catch (std::exception& e) {
51880       {
51881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51882       };
51883     } catch (...) {
51884       {
51885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51886       };
51887     }
51888   }
51889   jresult = result;
51890   return jresult;
51891 }
51892
51893
51894 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51895   unsigned long jresult ;
51896   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51897   std::size_t result;
51898
51899   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51900   {
51901     try {
51902       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);
51903     } catch (std::out_of_range& e) {
51904       {
51905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51906       };
51907     } catch (std::exception& e) {
51908       {
51909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51910       };
51911     } catch (...) {
51912       {
51913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51914       };
51915     }
51916   }
51917   jresult = (unsigned long)result;
51918   return jresult;
51919 }
51920
51921
51922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51923   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51924   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
51925
51926   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51927   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
51928   {
51929     try {
51930       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51931     } catch (std::out_of_range& e) {
51932       {
51933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51934       };
51935     } catch (std::exception& e) {
51936       {
51937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51938       };
51939     } catch (...) {
51940       {
51941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51942       };
51943     }
51944   }
51945 }
51946
51947
51948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51949   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51950   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
51951
51952   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51953   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
51954   {
51955     try {
51956       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51957     } catch (std::out_of_range& e) {
51958       {
51959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51960       };
51961     } catch (std::exception& e) {
51962       {
51963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51964       };
51965     } catch (...) {
51966       {
51967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51968       };
51969     }
51970   }
51971 }
51972
51973
51974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51975   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51976   Dali::Actor arg2 ;
51977   Dali::TapGesture *arg3 = 0 ;
51978   Dali::Actor *argp2 ;
51979
51980   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51981   argp2 = (Dali::Actor *)jarg2;
51982   if (!argp2) {
51983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51984     return ;
51985   }
51986   arg2 = *argp2;
51987   arg3 = (Dali::TapGesture *)jarg3;
51988   if (!arg3) {
51989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
51990     return ;
51991   }
51992   {
51993     try {
51994       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
51995     } catch (std::out_of_range& e) {
51996       {
51997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51998       };
51999     } catch (std::exception& e) {
52000       {
52001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52002       };
52003     } catch (...) {
52004       {
52005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52006       };
52007     }
52008   }
52009 }
52010
52011
52012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
52013   void * jresult ;
52014   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
52015
52016   {
52017     try {
52018       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
52019     } catch (std::out_of_range& e) {
52020       {
52021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52022       };
52023     } catch (std::exception& e) {
52024       {
52025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52026       };
52027     } catch (...) {
52028       {
52029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52030       };
52031     }
52032   }
52033   jresult = (void *)result;
52034   return jresult;
52035 }
52036
52037
52038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
52039   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52040
52041   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52042   {
52043     try {
52044       delete arg1;
52045     } catch (std::out_of_range& e) {
52046       {
52047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52048       };
52049     } catch (std::exception& e) {
52050       {
52051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52052       };
52053     } catch (...) {
52054       {
52055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52056       };
52057     }
52058   }
52059 }
52060
52061
52062 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AnimationSignal_Empty(void * jarg1) {
52063   unsigned int jresult ;
52064   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52065   bool result;
52066
52067   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52068   {
52069     try {
52070       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Animation &) > const *)arg1);
52071     } catch (std::out_of_range& e) {
52072       {
52073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52074       };
52075     } catch (std::exception& e) {
52076       {
52077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52078       };
52079     } catch (...) {
52080       {
52081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52082       };
52083     }
52084   }
52085   jresult = result;
52086   return jresult;
52087 }
52088
52089
52090 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AnimationSignal_GetConnectionCount(void * jarg1) {
52091   unsigned long jresult ;
52092   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52093   std::size_t result;
52094
52095   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52096   {
52097     try {
52098       result = Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Animation &) > const *)arg1);
52099     } catch (std::out_of_range& e) {
52100       {
52101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52102       };
52103     } catch (std::exception& e) {
52104       {
52105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52106       };
52107     } catch (...) {
52108       {
52109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52110       };
52111     }
52112   }
52113   jresult = (unsigned long)result;
52114   return jresult;
52115 }
52116
52117
52118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Connect(void * jarg1, void * jarg2) {
52119   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52120   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52121
52122   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52123   arg2 = (void (*)(Dali::Animation &))jarg2;
52124   {
52125     try {
52126       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(arg1,arg2);
52127     } catch (std::out_of_range& e) {
52128       {
52129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52130       };
52131     } catch (std::exception& e) {
52132       {
52133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52134       };
52135     } catch (...) {
52136       {
52137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52138       };
52139     }
52140   }
52141 }
52142
52143
52144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Disconnect(void * jarg1, void * jarg2) {
52145   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52146   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52147
52148   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52149   arg2 = (void (*)(Dali::Animation &))jarg2;
52150   {
52151     try {
52152       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(arg1,arg2);
52153     } catch (std::out_of_range& e) {
52154       {
52155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52156       };
52157     } catch (std::exception& e) {
52158       {
52159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52160       };
52161     } catch (...) {
52162       {
52163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52164       };
52165     }
52166   }
52167 }
52168
52169
52170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Emit(void * jarg1, void * jarg2) {
52171   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52172   Dali::Animation *arg2 = 0 ;
52173
52174   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52175   arg2 = (Dali::Animation *)jarg2;
52176   if (!arg2) {
52177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
52178     return ;
52179   }
52180   {
52181     try {
52182       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(arg1,*arg2);
52183     } catch (std::out_of_range& e) {
52184       {
52185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52186       };
52187     } catch (std::exception& e) {
52188       {
52189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52190       };
52191     } catch (...) {
52192       {
52193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52194       };
52195     }
52196   }
52197 }
52198
52199
52200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimationSignal() {
52201   void * jresult ;
52202   Dali::Signal< void (Dali::Animation &) > *result = 0 ;
52203
52204   {
52205     try {
52206       result = (Dali::Signal< void (Dali::Animation &) > *)new Dali::Signal< void (Dali::Animation &) >();
52207     } catch (std::out_of_range& e) {
52208       {
52209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52210       };
52211     } catch (std::exception& e) {
52212       {
52213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52214       };
52215     } catch (...) {
52216       {
52217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52218       };
52219     }
52220   }
52221   jresult = (void *)result;
52222   return jresult;
52223 }
52224
52225
52226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimationSignal(void * jarg1) {
52227   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52228
52229   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52230   {
52231     try {
52232       delete arg1;
52233     } catch (std::out_of_range& e) {
52234       {
52235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52236       };
52237     } catch (std::exception& e) {
52238       {
52239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52240       };
52241     } catch (...) {
52242       {
52243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52244       };
52245     }
52246   }
52247 }
52248
52249
52250 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
52251   unsigned int jresult ;
52252   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52253   bool result;
52254
52255   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52256   {
52257     try {
52258       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52259     } catch (std::out_of_range& e) {
52260       {
52261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52262       };
52263     } catch (std::exception& e) {
52264       {
52265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52266       };
52267     } catch (...) {
52268       {
52269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52270       };
52271     }
52272   }
52273   jresult = result;
52274   return jresult;
52275 }
52276
52277
52278 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
52279   unsigned long jresult ;
52280   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52281   std::size_t result;
52282
52283   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52284   {
52285     try {
52286       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52287     } catch (std::out_of_range& e) {
52288       {
52289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52290       };
52291     } catch (std::exception& e) {
52292       {
52293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52294       };
52295     } catch (...) {
52296       {
52297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52298       };
52299     }
52300   }
52301   jresult = (unsigned long)result;
52302   return jresult;
52303 }
52304
52305
52306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
52307   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52308   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52309
52310   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52311   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52312   {
52313     try {
52314       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
52315     } catch (std::out_of_range& e) {
52316       {
52317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52318       };
52319     } catch (std::exception& e) {
52320       {
52321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52322       };
52323     } catch (...) {
52324       {
52325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52326       };
52327     }
52328   }
52329 }
52330
52331
52332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
52333   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52334   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52335
52336   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52337   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52338   {
52339     try {
52340       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
52341     } catch (std::out_of_range& e) {
52342       {
52343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52344       };
52345     } catch (std::exception& e) {
52346       {
52347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52348       };
52349     } catch (...) {
52350       {
52351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52352       };
52353     }
52354   }
52355 }
52356
52357
52358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
52359   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52360   Dali::ResourceImage arg2 ;
52361   Dali::ResourceImage *argp2 ;
52362
52363   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52364   argp2 = (Dali::ResourceImage *)jarg2;
52365   if (!argp2) {
52366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
52367     return ;
52368   }
52369   arg2 = *argp2;
52370   {
52371     try {
52372       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
52373     } catch (std::out_of_range& e) {
52374       {
52375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52376       };
52377     } catch (std::exception& e) {
52378       {
52379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52380       };
52381     } catch (...) {
52382       {
52383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52384       };
52385     }
52386   }
52387 }
52388
52389
52390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
52391   void * jresult ;
52392   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
52393
52394   {
52395     try {
52396       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
52397     } catch (std::out_of_range& e) {
52398       {
52399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52400       };
52401     } catch (std::exception& e) {
52402       {
52403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52404       };
52405     } catch (...) {
52406       {
52407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52408       };
52409     }
52410   }
52411   jresult = (void *)result;
52412   return jresult;
52413 }
52414
52415
52416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
52417   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52418
52419   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52420   {
52421     try {
52422       delete arg1;
52423     } catch (std::out_of_range& e) {
52424       {
52425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52426       };
52427     } catch (std::exception& e) {
52428       {
52429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52430       };
52431     } catch (...) {
52432       {
52433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52434       };
52435     }
52436   }
52437 }
52438
52439
52440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
52441   void * jresult ;
52442   Dali::Timer *result = 0 ;
52443
52444   {
52445     try {
52446       result = (Dali::Timer *)new Dali::Timer();
52447     } catch (std::out_of_range& e) {
52448       {
52449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52450       };
52451     } catch (std::exception& e) {
52452       {
52453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52454       };
52455     } catch (...) {
52456       {
52457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52458       };
52459     }
52460   }
52461   jresult = (void *)result;
52462   return jresult;
52463 }
52464
52465
52466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
52467   void * jresult ;
52468   unsigned int arg1 ;
52469   Dali::Timer result;
52470
52471   arg1 = (unsigned int)jarg1;
52472   {
52473     try {
52474       result = Dali::Timer::New(arg1);
52475     } catch (std::out_of_range& e) {
52476       {
52477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52478       };
52479     } catch (std::exception& e) {
52480       {
52481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52482       };
52483     } catch (...) {
52484       {
52485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52486       };
52487     }
52488   }
52489   jresult = new Dali::Timer((const Dali::Timer &)result);
52490   return jresult;
52491 }
52492
52493
52494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
52495   void * jresult ;
52496   Dali::Timer *arg1 = 0 ;
52497   Dali::Timer *result = 0 ;
52498
52499   arg1 = (Dali::Timer *)jarg1;
52500   if (!arg1) {
52501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52502     return 0;
52503   }
52504   {
52505     try {
52506       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
52507     } catch (std::out_of_range& e) {
52508       {
52509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52510       };
52511     } catch (std::exception& e) {
52512       {
52513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52514       };
52515     } catch (...) {
52516       {
52517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52518       };
52519     }
52520   }
52521   jresult = (void *)result;
52522   return jresult;
52523 }
52524
52525
52526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
52527   void * jresult ;
52528   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52529   Dali::Timer *arg2 = 0 ;
52530   Dali::Timer *result = 0 ;
52531
52532   arg1 = (Dali::Timer *)jarg1;
52533   arg2 = (Dali::Timer *)jarg2;
52534   if (!arg2) {
52535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52536     return 0;
52537   }
52538   {
52539     try {
52540       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
52541     } catch (std::out_of_range& e) {
52542       {
52543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52544       };
52545     } catch (std::exception& e) {
52546       {
52547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52548       };
52549     } catch (...) {
52550       {
52551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52552       };
52553     }
52554   }
52555   jresult = (void *)result;
52556   return jresult;
52557 }
52558
52559
52560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
52561   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52562
52563   arg1 = (Dali::Timer *)jarg1;
52564   {
52565     try {
52566       delete arg1;
52567     } catch (std::out_of_range& e) {
52568       {
52569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52570       };
52571     } catch (std::exception& e) {
52572       {
52573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52574       };
52575     } catch (...) {
52576       {
52577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52578       };
52579     }
52580   }
52581 }
52582
52583
52584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
52585   void * jresult ;
52586   Dali::BaseHandle arg1 ;
52587   Dali::BaseHandle *argp1 ;
52588   Dali::Timer result;
52589
52590   argp1 = (Dali::BaseHandle *)jarg1;
52591   if (!argp1) {
52592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
52593     return 0;
52594   }
52595   arg1 = *argp1;
52596   {
52597     try {
52598       result = Dali::Timer::DownCast(arg1);
52599     } catch (std::out_of_range& e) {
52600       {
52601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52602       };
52603     } catch (std::exception& e) {
52604       {
52605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52606       };
52607     } catch (...) {
52608       {
52609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52610       };
52611     }
52612   }
52613   jresult = new Dali::Timer((const Dali::Timer &)result);
52614   return jresult;
52615 }
52616
52617
52618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
52619   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52620
52621   arg1 = (Dali::Timer *)jarg1;
52622   {
52623     try {
52624       (arg1)->Start();
52625     } catch (std::out_of_range& e) {
52626       {
52627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52628       };
52629     } catch (std::exception& e) {
52630       {
52631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52632       };
52633     } catch (...) {
52634       {
52635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52636       };
52637     }
52638   }
52639 }
52640
52641
52642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
52643   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52644
52645   arg1 = (Dali::Timer *)jarg1;
52646   {
52647     try {
52648       (arg1)->Stop();
52649     } catch (std::out_of_range& e) {
52650       {
52651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52652       };
52653     } catch (std::exception& e) {
52654       {
52655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52656       };
52657     } catch (...) {
52658       {
52659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52660       };
52661     }
52662   }
52663 }
52664
52665
52666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
52667   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52668   unsigned int arg2 ;
52669
52670   arg1 = (Dali::Timer *)jarg1;
52671   arg2 = (unsigned int)jarg2;
52672   {
52673     try {
52674       (arg1)->SetInterval(arg2);
52675     } catch (std::out_of_range& e) {
52676       {
52677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52678       };
52679     } catch (std::exception& e) {
52680       {
52681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52682       };
52683     } catch (...) {
52684       {
52685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52686       };
52687     }
52688   }
52689 }
52690
52691
52692 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
52693   unsigned int jresult ;
52694   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52695   unsigned int result;
52696
52697   arg1 = (Dali::Timer *)jarg1;
52698   {
52699     try {
52700       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
52701     } catch (std::out_of_range& e) {
52702       {
52703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52704       };
52705     } catch (std::exception& e) {
52706       {
52707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52708       };
52709     } catch (...) {
52710       {
52711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52712       };
52713     }
52714   }
52715   jresult = result;
52716   return jresult;
52717 }
52718
52719
52720 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
52721   unsigned int jresult ;
52722   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52723   bool result;
52724
52725   arg1 = (Dali::Timer *)jarg1;
52726   {
52727     try {
52728       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
52729     } catch (std::out_of_range& e) {
52730       {
52731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52732       };
52733     } catch (std::exception& e) {
52734       {
52735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52736       };
52737     } catch (...) {
52738       {
52739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52740       };
52741     }
52742   }
52743   jresult = result;
52744   return jresult;
52745 }
52746
52747
52748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
52749   void * jresult ;
52750   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52751   Dali::Timer::TimerSignalType *result = 0 ;
52752
52753   arg1 = (Dali::Timer *)jarg1;
52754   {
52755     try {
52756       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
52757     } catch (std::out_of_range& e) {
52758       {
52759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52760       };
52761     } catch (std::exception& e) {
52762       {
52763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52764       };
52765     } catch (...) {
52766       {
52767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52768       };
52769     }
52770   }
52771   jresult = (void *)result;
52772   return jresult;
52773 }
52774
52775
52776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
52777   void * jresult ;
52778   Dali::DragAndDropDetector *result = 0 ;
52779
52780   {
52781     try {
52782       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
52783     } catch (std::out_of_range& e) {
52784       {
52785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52786       };
52787     } catch (std::exception& e) {
52788       {
52789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52790       };
52791     } catch (...) {
52792       {
52793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52794       };
52795     }
52796   }
52797   jresult = (void *)result;
52798   return jresult;
52799 }
52800
52801
52802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
52803   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52804
52805   arg1 = (Dali::DragAndDropDetector *)jarg1;
52806   {
52807     try {
52808       delete arg1;
52809     } catch (std::out_of_range& e) {
52810       {
52811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52812       };
52813     } catch (std::exception& e) {
52814       {
52815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52816       };
52817     } catch (...) {
52818       {
52819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52820       };
52821     }
52822   }
52823 }
52824
52825
52826 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
52827   char * jresult ;
52828   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52829   std::string *result = 0 ;
52830
52831   arg1 = (Dali::DragAndDropDetector *)jarg1;
52832   {
52833     try {
52834       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
52835     } catch (std::out_of_range& e) {
52836       {
52837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52838       };
52839     } catch (std::exception& e) {
52840       {
52841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52842       };
52843     } catch (...) {
52844       {
52845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52846       };
52847     }
52848   }
52849   jresult = SWIG_csharp_string_callback(result->c_str());
52850   return jresult;
52851 }
52852
52853
52854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
52855   void * jresult ;
52856   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52857   Dali::Vector2 result;
52858
52859   arg1 = (Dali::DragAndDropDetector *)jarg1;
52860   {
52861     try {
52862       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
52863     } catch (std::out_of_range& e) {
52864       {
52865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52866       };
52867     } catch (std::exception& e) {
52868       {
52869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52870       };
52871     } catch (...) {
52872       {
52873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52874       };
52875     }
52876   }
52877   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
52878   return jresult;
52879 }
52880
52881
52882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
52883   void * jresult ;
52884   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52885   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
52886
52887   arg1 = (Dali::DragAndDropDetector *)jarg1;
52888   {
52889     try {
52890       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
52891     } catch (std::out_of_range& e) {
52892       {
52893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52894       };
52895     } catch (std::exception& e) {
52896       {
52897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52898       };
52899     } catch (...) {
52900       {
52901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52902       };
52903     }
52904   }
52905   jresult = (void *)result;
52906   return jresult;
52907 }
52908
52909
52910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
52911   void * jresult ;
52912   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52913   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
52914
52915   arg1 = (Dali::DragAndDropDetector *)jarg1;
52916   {
52917     try {
52918       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
52919     } catch (std::out_of_range& e) {
52920       {
52921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52922       };
52923     } catch (std::exception& e) {
52924       {
52925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52926       };
52927     } catch (...) {
52928       {
52929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52930       };
52931     }
52932   }
52933   jresult = (void *)result;
52934   return jresult;
52935 }
52936
52937
52938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
52939   void * jresult ;
52940   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52941   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
52942
52943   arg1 = (Dali::DragAndDropDetector *)jarg1;
52944   {
52945     try {
52946       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
52947     } catch (std::out_of_range& e) {
52948       {
52949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52950       };
52951     } catch (std::exception& e) {
52952       {
52953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52954       };
52955     } catch (...) {
52956       {
52957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52958       };
52959     }
52960   }
52961   jresult = (void *)result;
52962   return jresult;
52963 }
52964
52965
52966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
52967   void * jresult ;
52968   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52969   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
52970
52971   arg1 = (Dali::DragAndDropDetector *)jarg1;
52972   {
52973     try {
52974       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
52975     } catch (std::out_of_range& e) {
52976       {
52977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52978       };
52979     } catch (std::exception& e) {
52980       {
52981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52982       };
52983     } catch (...) {
52984       {
52985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52986       };
52987     }
52988   }
52989   jresult = (void *)result;
52990   return jresult;
52991 }
52992
52993
52994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
52995   void * jresult ;
52996   Dali::ApplicationExtensions *result = 0 ;
52997
52998   {
52999     try {
53000       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
53001     } catch (std::out_of_range& e) {
53002       {
53003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53004       };
53005     } catch (std::exception& e) {
53006       {
53007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53008       };
53009     } catch (...) {
53010       {
53011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53012       };
53013     }
53014   }
53015   jresult = (void *)result;
53016   return jresult;
53017 }
53018
53019
53020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
53021   void * jresult ;
53022   Dali::Application *arg1 = (Dali::Application *) 0 ;
53023   Dali::ApplicationExtensions *result = 0 ;
53024
53025   arg1 = (Dali::Application *)jarg1;
53026   {
53027     try {
53028       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
53029     } catch (std::out_of_range& e) {
53030       {
53031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53032       };
53033     } catch (std::exception& e) {
53034       {
53035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53036       };
53037     } catch (...) {
53038       {
53039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53040       };
53041     }
53042   }
53043   jresult = (void *)result;
53044   return jresult;
53045 }
53046
53047
53048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
53049   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53050
53051   arg1 = (Dali::ApplicationExtensions *)jarg1;
53052   {
53053     try {
53054       delete arg1;
53055     } catch (std::out_of_range& e) {
53056       {
53057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53058       };
53059     } catch (std::exception& e) {
53060       {
53061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53062       };
53063     } catch (...) {
53064       {
53065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53066       };
53067     }
53068   }
53069 }
53070
53071
53072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Init(void * jarg1) {
53073   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53074
53075   arg1 = (Dali::ApplicationExtensions *)jarg1;
53076   {
53077     try {
53078       (arg1)->Init();
53079     } catch (std::out_of_range& e) {
53080       {
53081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53082       };
53083     } catch (std::exception& e) {
53084       {
53085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53086       };
53087     } catch (...) {
53088       {
53089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53090       };
53091     }
53092   }
53093 }
53094
53095
53096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
53097   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53098
53099   arg1 = (Dali::ApplicationExtensions *)jarg1;
53100   {
53101     try {
53102       (arg1)->Terminate();
53103     } catch (std::out_of_range& e) {
53104       {
53105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53106       };
53107     } catch (std::exception& e) {
53108       {
53109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53110       };
53111     } catch (...) {
53112       {
53113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53114       };
53115     }
53116   }
53117 }
53118
53119
53120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
53121   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53122
53123   arg1 = (Dali::ApplicationExtensions *)jarg1;
53124   {
53125     try {
53126       (arg1)->Pause();
53127     } catch (std::out_of_range& e) {
53128       {
53129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53130       };
53131     } catch (std::exception& e) {
53132       {
53133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53134       };
53135     } catch (...) {
53136       {
53137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53138       };
53139     }
53140   }
53141 }
53142
53143
53144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
53145   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53146
53147   arg1 = (Dali::ApplicationExtensions *)jarg1;
53148   {
53149     try {
53150       (arg1)->Resume();
53151     } catch (std::out_of_range& e) {
53152       {
53153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53154       };
53155     } catch (std::exception& e) {
53156       {
53157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53158       };
53159     } catch (...) {
53160       {
53161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53162       };
53163     }
53164   }
53165 }
53166
53167
53168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
53169   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53170
53171   arg1 = (Dali::ApplicationExtensions *)jarg1;
53172   {
53173     try {
53174       (arg1)->LanguageChange();
53175     } catch (std::out_of_range& e) {
53176       {
53177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53178       };
53179     } catch (std::exception& e) {
53180       {
53181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53182       };
53183     } catch (...) {
53184       {
53185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53186       };
53187     }
53188   }
53189 }
53190
53191
53192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3) {
53193   void * jresult ;
53194   Dali::PositionSize arg1 ;
53195   std::string *arg2 = 0 ;
53196   bool arg3 ;
53197   Dali::PositionSize *argp1 ;
53198   Dali::Window result;
53199
53200   argp1 = (Dali::PositionSize *)jarg1;
53201   if (!argp1) {
53202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53203     return 0;
53204   }
53205   arg1 = *argp1;
53206   if (!jarg2) {
53207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53208     return 0;
53209   }
53210   std::string arg2_str(jarg2);
53211   arg2 = &arg2_str;
53212   arg3 = jarg3 ? true : false;
53213   {
53214     try {
53215       result = Dali::Window::New(arg1,(std::string const &)*arg2,arg3);
53216     } catch (std::out_of_range& e) {
53217       {
53218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53219       };
53220     } catch (std::exception& e) {
53221       {
53222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53223       };
53224     } catch (...) {
53225       {
53226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53227       };
53228     }
53229   }
53230   jresult = new Dali::Window((const Dali::Window &)result);
53231
53232   //argout typemap for const std::string&
53233
53234   return jresult;
53235 }
53236
53237
53238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_1(void * jarg1, char * jarg2) {
53239   void * jresult ;
53240   Dali::PositionSize arg1 ;
53241   std::string *arg2 = 0 ;
53242   Dali::PositionSize *argp1 ;
53243   Dali::Window result;
53244
53245   argp1 = (Dali::PositionSize *)jarg1;
53246   if (!argp1) {
53247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53248     return 0;
53249   }
53250   arg1 = *argp1;
53251   if (!jarg2) {
53252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53253     return 0;
53254   }
53255   std::string arg2_str(jarg2);
53256   arg2 = &arg2_str;
53257   {
53258     try {
53259       result = Dali::Window::New(arg1,(std::string const &)*arg2);
53260     } catch (std::out_of_range& e) {
53261       {
53262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53263       };
53264     } catch (std::exception& e) {
53265       {
53266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53267       };
53268     } catch (...) {
53269       {
53270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53271       };
53272     }
53273   }
53274   jresult = new Dali::Window((const Dali::Window &)result);
53275
53276   //argout typemap for const std::string&
53277
53278   return jresult;
53279 }
53280
53281
53282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_2(void * jarg1, char * jarg2, char * jarg3, unsigned int jarg4) {
53283   void * jresult ;
53284   Dali::PositionSize arg1 ;
53285   std::string *arg2 = 0 ;
53286   std::string *arg3 = 0 ;
53287   bool arg4 ;
53288   Dali::PositionSize *argp1 ;
53289   Dali::Window result;
53290
53291   argp1 = (Dali::PositionSize *)jarg1;
53292   if (!argp1) {
53293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53294     return 0;
53295   }
53296   arg1 = *argp1;
53297   if (!jarg2) {
53298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53299     return 0;
53300   }
53301   std::string arg2_str(jarg2);
53302   arg2 = &arg2_str;
53303   if (!jarg3) {
53304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53305     return 0;
53306   }
53307   std::string arg3_str(jarg3);
53308   arg3 = &arg3_str;
53309   arg4 = jarg4 ? true : false;
53310   {
53311     try {
53312       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4);
53313     } catch (std::out_of_range& e) {
53314       {
53315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53316       };
53317     } catch (std::exception& e) {
53318       {
53319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53320       };
53321     } catch (...) {
53322       {
53323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53324       };
53325     }
53326   }
53327   jresult = new Dali::Window((const Dali::Window &)result);
53328
53329   //argout typemap for const std::string&
53330
53331
53332   //argout typemap for const std::string&
53333
53334   return jresult;
53335 }
53336
53337
53338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_3(void * jarg1, char * jarg2, char * jarg3) {
53339   void * jresult ;
53340   Dali::PositionSize arg1 ;
53341   std::string *arg2 = 0 ;
53342   std::string *arg3 = 0 ;
53343   Dali::PositionSize *argp1 ;
53344   Dali::Window result;
53345
53346   argp1 = (Dali::PositionSize *)jarg1;
53347   if (!argp1) {
53348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53349     return 0;
53350   }
53351   arg1 = *argp1;
53352   if (!jarg2) {
53353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53354     return 0;
53355   }
53356   std::string arg2_str(jarg2);
53357   arg2 = &arg2_str;
53358   if (!jarg3) {
53359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53360     return 0;
53361   }
53362   std::string arg3_str(jarg3);
53363   arg3 = &arg3_str;
53364   {
53365     try {
53366       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
53367     } catch (std::out_of_range& e) {
53368       {
53369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53370       };
53371     } catch (std::exception& e) {
53372       {
53373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53374       };
53375     } catch (...) {
53376       {
53377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53378       };
53379     }
53380   }
53381   jresult = new Dali::Window((const Dali::Window &)result);
53382
53383   //argout typemap for const std::string&
53384
53385
53386   //argout typemap for const std::string&
53387
53388   return jresult;
53389 }
53390
53391
53392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_0() {
53393   void * jresult ;
53394   Dali::Window *result = 0 ;
53395
53396   {
53397     try {
53398       result = (Dali::Window *)new Dali::Window();
53399     } catch (std::out_of_range& e) {
53400       {
53401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53402       };
53403     } catch (std::exception& e) {
53404       {
53405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53406       };
53407     } catch (...) {
53408       {
53409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53410       };
53411     }
53412   }
53413   jresult = (void *)result;
53414   return jresult;
53415 }
53416
53417
53418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Window(void * jarg1) {
53419   Dali::Window *arg1 = (Dali::Window *) 0 ;
53420
53421   arg1 = (Dali::Window *)jarg1;
53422   {
53423     try {
53424       delete arg1;
53425     } catch (std::out_of_range& e) {
53426       {
53427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53428       };
53429     } catch (std::exception& e) {
53430       {
53431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53432       };
53433     } catch (...) {
53434       {
53435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53436       };
53437     }
53438   }
53439 }
53440
53441
53442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_1(void * jarg1) {
53443   void * jresult ;
53444   Dali::Window *arg1 = 0 ;
53445   Dali::Window *result = 0 ;
53446
53447   arg1 = (Dali::Window *)jarg1;
53448   if (!arg1) {
53449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
53450     return 0;
53451   }
53452   {
53453     try {
53454       result = (Dali::Window *)new Dali::Window((Dali::Window const &)*arg1);
53455     } catch (std::out_of_range& e) {
53456       {
53457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53458       };
53459     } catch (std::exception& e) {
53460       {
53461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53462       };
53463     } catch (...) {
53464       {
53465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53466       };
53467     }
53468   }
53469   jresult = (void *)result;
53470   return jresult;
53471 }
53472
53473
53474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Assign(void * jarg1, void * jarg2) {
53475   void * jresult ;
53476   Dali::Window *arg1 = (Dali::Window *) 0 ;
53477   Dali::Window *arg2 = 0 ;
53478   Dali::Window *result = 0 ;
53479
53480   arg1 = (Dali::Window *)jarg1;
53481   arg2 = (Dali::Window *)jarg2;
53482   if (!arg2) {
53483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
53484     return 0;
53485   }
53486   {
53487     try {
53488       result = (Dali::Window *) &(arg1)->operator =((Dali::Window const &)*arg2);
53489     } catch (std::out_of_range& e) {
53490       {
53491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53492       };
53493     } catch (std::exception& e) {
53494       {
53495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53496       };
53497     } catch (...) {
53498       {
53499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53500       };
53501     }
53502   }
53503   jresult = (void *)result;
53504   return jresult;
53505 }
53506
53507
53508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_ShowIndicator(void * jarg1, int jarg2) {
53509   Dali::Window *arg1 = (Dali::Window *) 0 ;
53510   Dali::Window::IndicatorVisibleMode arg2 ;
53511
53512   arg1 = (Dali::Window *)jarg1;
53513   arg2 = (Dali::Window::IndicatorVisibleMode)jarg2;
53514   {
53515     try {
53516       (arg1)->ShowIndicator(arg2);
53517     } catch (std::out_of_range& e) {
53518       {
53519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53520       };
53521     } catch (std::exception& e) {
53522       {
53523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53524       };
53525     } catch (...) {
53526       {
53527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53528       };
53529     }
53530   }
53531 }
53532
53533
53534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetIndicatorBgOpacity(void * jarg1, int jarg2) {
53535   Dali::Window *arg1 = (Dali::Window *) 0 ;
53536   Dali::Window::IndicatorBgOpacity arg2 ;
53537
53538   arg1 = (Dali::Window *)jarg1;
53539   arg2 = (Dali::Window::IndicatorBgOpacity)jarg2;
53540   {
53541     try {
53542       (arg1)->SetIndicatorBgOpacity(arg2);
53543     } catch (std::out_of_range& e) {
53544       {
53545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53546       };
53547     } catch (std::exception& e) {
53548       {
53549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53550       };
53551     } catch (...) {
53552       {
53553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53554       };
53555     }
53556   }
53557 }
53558
53559
53560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RotateIndicator(void * jarg1, int jarg2) {
53561   Dali::Window *arg1 = (Dali::Window *) 0 ;
53562   Dali::Window::WindowOrientation arg2 ;
53563
53564   arg1 = (Dali::Window *)jarg1;
53565   arg2 = (Dali::Window::WindowOrientation)jarg2;
53566   {
53567     try {
53568       (arg1)->RotateIndicator(arg2);
53569     } catch (std::out_of_range& e) {
53570       {
53571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53572       };
53573     } catch (std::exception& e) {
53574       {
53575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53576       };
53577     } catch (...) {
53578       {
53579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53580       };
53581     }
53582   }
53583 }
53584
53585
53586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetClass(void * jarg1, char * jarg2, char * jarg3) {
53587   Dali::Window *arg1 = (Dali::Window *) 0 ;
53588   std::string arg2 ;
53589   std::string arg3 ;
53590
53591   arg1 = (Dali::Window *)jarg1;
53592   if (!jarg2) {
53593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53594     return ;
53595   }
53596   (&arg2)->assign(jarg2);
53597   if (!jarg3) {
53598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53599     return ;
53600   }
53601   (&arg3)->assign(jarg3);
53602   {
53603     try {
53604       (arg1)->SetClass(arg2,arg3);
53605     } catch (std::out_of_range& e) {
53606       {
53607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53608       };
53609     } catch (std::exception& e) {
53610       {
53611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53612       };
53613     } catch (...) {
53614       {
53615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53616       };
53617     }
53618   }
53619 }
53620
53621
53622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Raise(void * jarg1) {
53623   Dali::Window *arg1 = (Dali::Window *) 0 ;
53624
53625   arg1 = (Dali::Window *)jarg1;
53626   {
53627     try {
53628       (arg1)->Raise();
53629     } catch (std::out_of_range& e) {
53630       {
53631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53632       };
53633     } catch (std::exception& e) {
53634       {
53635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53636       };
53637     } catch (...) {
53638       {
53639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53640       };
53641     }
53642   }
53643 }
53644
53645
53646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Lower(void * jarg1) {
53647   Dali::Window *arg1 = (Dali::Window *) 0 ;
53648
53649   arg1 = (Dali::Window *)jarg1;
53650   {
53651     try {
53652       (arg1)->Lower();
53653     } catch (std::out_of_range& e) {
53654       {
53655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53656       };
53657     } catch (std::exception& e) {
53658       {
53659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53660       };
53661     } catch (...) {
53662       {
53663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53664       };
53665     }
53666   }
53667 }
53668
53669
53670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Activate(void * jarg1) {
53671   Dali::Window *arg1 = (Dali::Window *) 0 ;
53672
53673   arg1 = (Dali::Window *)jarg1;
53674   {
53675     try {
53676       (arg1)->Activate();
53677     } catch (std::out_of_range& e) {
53678       {
53679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53680       };
53681     } catch (std::exception& e) {
53682       {
53683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53684       };
53685     } catch (...) {
53686       {
53687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53688       };
53689     }
53690   }
53691 }
53692
53693
53694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_AddAvailableOrientation(void * jarg1, int jarg2) {
53695   Dali::Window *arg1 = (Dali::Window *) 0 ;
53696   Dali::Window::WindowOrientation arg2 ;
53697
53698   arg1 = (Dali::Window *)jarg1;
53699   arg2 = (Dali::Window::WindowOrientation)jarg2;
53700   {
53701     try {
53702       (arg1)->AddAvailableOrientation(arg2);
53703     } catch (std::out_of_range& e) {
53704       {
53705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53706       };
53707     } catch (std::exception& e) {
53708       {
53709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53710       };
53711     } catch (...) {
53712       {
53713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53714       };
53715     }
53716   }
53717 }
53718
53719
53720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RemoveAvailableOrientation(void * jarg1, int jarg2) {
53721   Dali::Window *arg1 = (Dali::Window *) 0 ;
53722   Dali::Window::WindowOrientation arg2 ;
53723
53724   arg1 = (Dali::Window *)jarg1;
53725   arg2 = (Dali::Window::WindowOrientation)jarg2;
53726   {
53727     try {
53728       (arg1)->RemoveAvailableOrientation(arg2);
53729     } catch (std::out_of_range& e) {
53730       {
53731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53732       };
53733     } catch (std::exception& e) {
53734       {
53735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53736       };
53737     } catch (...) {
53738       {
53739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53740       };
53741     }
53742   }
53743 }
53744
53745
53746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPreferredOrientation(void * jarg1, int jarg2) {
53747   Dali::Window *arg1 = (Dali::Window *) 0 ;
53748   Dali::Window::WindowOrientation arg2 ;
53749
53750   arg1 = (Dali::Window *)jarg1;
53751   arg2 = (Dali::Window::WindowOrientation)jarg2;
53752   {
53753     try {
53754       (arg1)->SetPreferredOrientation(arg2);
53755     } catch (std::out_of_range& e) {
53756       {
53757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53758       };
53759     } catch (std::exception& e) {
53760       {
53761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53762       };
53763     } catch (...) {
53764       {
53765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53766       };
53767     }
53768   }
53769 }
53770
53771
53772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Window_GetPreferredOrientation(void * jarg1) {
53773   int jresult ;
53774   Dali::Window *arg1 = (Dali::Window *) 0 ;
53775   Dali::Window::WindowOrientation result;
53776
53777   arg1 = (Dali::Window *)jarg1;
53778   {
53779     try {
53780       result = (Dali::Window::WindowOrientation)(arg1)->GetPreferredOrientation();
53781     } catch (std::out_of_range& e) {
53782       {
53783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53784       };
53785     } catch (std::exception& e) {
53786       {
53787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53788       };
53789     } catch (...) {
53790       {
53791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53792       };
53793     }
53794   }
53795   jresult = (int)result;
53796   return jresult;
53797 }
53798
53799
53800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetDragAndDropDetector(void * jarg1) {
53801   void * jresult ;
53802   Dali::Window *arg1 = (Dali::Window *) 0 ;
53803   Dali::DragAndDropDetector result;
53804
53805   arg1 = (Dali::Window *)jarg1;
53806   {
53807     try {
53808       result = ((Dali::Window const *)arg1)->GetDragAndDropDetector();
53809     } catch (std::out_of_range& e) {
53810       {
53811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53812       };
53813     } catch (std::exception& e) {
53814       {
53815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53816       };
53817     } catch (...) {
53818       {
53819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53820       };
53821     }
53822   }
53823   jresult = new Dali::DragAndDropDetector((const Dali::DragAndDropDetector &)result);
53824   return jresult;
53825 }
53826
53827
53828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetNativeHandle(void * jarg1) {
53829   void * jresult ;
53830   Dali::Window *arg1 = (Dali::Window *) 0 ;
53831   Dali::Any result;
53832
53833   arg1 = (Dali::Window *)jarg1;
53834   {
53835     try {
53836       result = ((Dali::Window const *)arg1)->GetNativeHandle();
53837     } catch (std::out_of_range& e) {
53838       {
53839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53840       };
53841     } catch (std::exception& e) {
53842       {
53843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53844       };
53845     } catch (...) {
53846       {
53847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53848       };
53849     }
53850   }
53851   jresult = new Dali::Any((const Dali::Any &)result);
53852   return jresult;
53853 }
53854
53855
53856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_IndicatorVisibilityChangedSignal(void * jarg1) {
53857   void * jresult ;
53858   Dali::Window *arg1 = (Dali::Window *) 0 ;
53859   Dali::Window::IndicatorSignalType *result = 0 ;
53860
53861   arg1 = (Dali::Window *)jarg1;
53862   {
53863     try {
53864       result = (Dali::Window::IndicatorSignalType *) &(arg1)->IndicatorVisibilityChangedSignal();
53865     } catch (std::out_of_range& e) {
53866       {
53867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53868       };
53869     } catch (std::exception& e) {
53870       {
53871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53872       };
53873     } catch (...) {
53874       {
53875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53876       };
53877     }
53878   }
53879   jresult = (void *)result;
53880   return jresult;
53881 }
53882
53883
53884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FocusChangedSignal(void * jarg1) {
53885   void * jresult ;
53886   Dali::Window arg1 ;
53887   Dali::Window *argp1 ;
53888   Dali::DevelWindow::FocusSignalType *result = 0 ;
53889
53890   argp1 = (Dali::Window *)jarg1;
53891   if (!argp1) {
53892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
53893     return 0;
53894   }
53895   arg1 = *argp1;
53896   {
53897     try {
53898       result = (Dali::DevelWindow::FocusSignalType *) &Dali::DevelWindow::FocusChangedSignal(arg1);
53899     } catch (std::out_of_range& e) {
53900       {
53901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53902       };
53903     } catch (std::exception& e) {
53904       {
53905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53906       };
53907     } catch (...) {
53908       {
53909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53910       };
53911     }
53912   }
53913   jresult = (void *)result;
53914   return jresult;
53915 }
53916
53917
53918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetAcceptFocus(void * jarg1, unsigned int jarg2) {
53919   Dali::Window arg1 ;
53920   bool arg2 ;
53921   Dali::Window *argp1 ;
53922
53923   argp1 = (Dali::Window *)jarg1;
53924   if (!argp1) {
53925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
53926     return ;
53927   }
53928   arg1 = *argp1;
53929   arg2 = jarg2 ? true : false;
53930   {
53931     try {
53932       Dali::DevelWindow::SetAcceptFocus(arg1,arg2);
53933     } catch (std::out_of_range& e) {
53934       {
53935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53936       };
53937     } catch (std::exception& e) {
53938       {
53939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53940       };
53941     } catch (...) {
53942       {
53943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53944       };
53945     }
53946   }
53947 }
53948
53949
53950 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsFocusAcceptable(void * jarg1) {
53951   unsigned int jresult ;
53952   Dali::Window arg1 ;
53953   Dali::Window *argp1 ;
53954   bool result;
53955
53956   argp1 = (Dali::Window *)jarg1;
53957   if (!argp1) {
53958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
53959     return 0;
53960   }
53961   arg1 = *argp1;
53962   {
53963     try {
53964       result = (bool)Dali::DevelWindow::IsFocusAcceptable(arg1);
53965     } catch (std::out_of_range& e) {
53966       {
53967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53968       };
53969     } catch (std::exception& e) {
53970       {
53971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53972       };
53973     } catch (...) {
53974       {
53975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53976       };
53977     }
53978   }
53979   jresult = result;
53980   return jresult;
53981 }
53982
53983
53984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Show(void * jarg1) {
53985   Dali::Window arg1 ;
53986   Dali::Window *argp1 ;
53987
53988   argp1 = (Dali::Window *)jarg1;
53989   if (!argp1) {
53990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
53991     return ;
53992   }
53993   arg1 = *argp1;
53994   {
53995     try {
53996       Dali::DevelWindow::Show(arg1);
53997     } catch (std::out_of_range& e) {
53998       {
53999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54000       };
54001     } catch (std::exception& e) {
54002       {
54003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54004       };
54005     } catch (...) {
54006       {
54007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54008       };
54009     }
54010   }
54011 }
54012
54013
54014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hide(void * jarg1) {
54015   Dali::Window arg1 ;
54016   Dali::Window *argp1 ;
54017
54018   argp1 = (Dali::Window *)jarg1;
54019   if (!argp1) {
54020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54021     return ;
54022   }
54023   arg1 = *argp1;
54024   {
54025     try {
54026       Dali::DevelWindow::Hide(arg1);
54027     } catch (std::out_of_range& e) {
54028       {
54029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54030       };
54031     } catch (std::exception& e) {
54032       {
54033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54034       };
54035     } catch (...) {
54036       {
54037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54038       };
54039     }
54040   }
54041 }
54042
54043
54044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVisible(void * jarg1) {
54045   unsigned int jresult ;
54046   Dali::Window arg1 ;
54047   Dali::Window *argp1 ;
54048   bool result;
54049
54050   argp1 = (Dali::Window *)jarg1;
54051   if (!argp1) {
54052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54053     return 0;
54054   }
54055   arg1 = *argp1;
54056   {
54057     try {
54058       result = (bool)Dali::DevelWindow::IsVisible(arg1);
54059     } catch (std::out_of_range& e) {
54060       {
54061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54062       };
54063     } catch (std::exception& e) {
54064       {
54065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54066       };
54067     } catch (...) {
54068       {
54069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54070       };
54071     }
54072   }
54073   jresult = result;
54074   return jresult;
54075 }
54076
54077
54078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_0() {
54079   void * jresult ;
54080   Dali::Application result;
54081
54082   {
54083     try {
54084       result = Dali::Application::New();
54085     } catch (std::out_of_range& e) {
54086       {
54087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54088       };
54089     } catch (std::exception& e) {
54090       {
54091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54092       };
54093     } catch (...) {
54094       {
54095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54096       };
54097     }
54098   }
54099   jresult = new Dali::Application((const Dali::Application &)result);
54100   return jresult;
54101 }
54102
54103
54104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_1(int jarg1) {
54105   void * jresult ;
54106   int *arg1 = (int *) 0 ;
54107   char ***arg2 ;
54108   Dali::Application result;
54109
54110   {
54111     // Todo generate argv data from the C# args
54112     char **array;         // two dimensional array
54113     int numStrings = 1;     // number of strings
54114     int stringLength = 30;      // max string length.
54115     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
54116     argV = array;
54117
54118     // allocate the string data
54119     for( int i=0; i < numStrings; i++)
54120     {
54121       array[i]=(char *)malloc( stringLength * sizeof(char *) );
54122     }
54123     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
54124
54125     strcpy( array[0], "dali-csharp-app");
54126
54127     arg1 = &argC;
54128     arg2 = &argV;
54129   }
54130   {
54131     try {
54132       result = Dali::Application::New(arg1,arg2);
54133     } catch (std::out_of_range& e) {
54134       {
54135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54136       };
54137     } catch (std::exception& e) {
54138       {
54139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54140       };
54141     } catch (...) {
54142       {
54143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54144       };
54145     }
54146   }
54147   jresult = new Dali::Application((const Dali::Application &)result);
54148   return jresult;
54149 }
54150
54151
54152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_2(int jarg1, char * jarg3) {
54153   void * jresult ;
54154   int *arg1 = (int *) 0 ;
54155   char ***arg2 ;
54156   std::string *arg3 = 0 ;
54157   Dali::Application result;
54158
54159   {
54160     // Todo generate argv data from the C# args
54161     char **array;         // two dimensional array
54162     int numStrings = 1;     // number of strings
54163     int stringLength = 30;      // max string length.
54164     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
54165     argV = array;
54166
54167     // allocate the string data
54168     for( int i=0; i < numStrings; i++)
54169     {
54170       array[i]=(char *)malloc( stringLength * sizeof(char *) );
54171     }
54172     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
54173
54174     strcpy( array[0], "dali-csharp-app");
54175
54176     arg1 = &argC;
54177     arg2 = &argV;
54178   }
54179   if (!jarg3) {
54180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54181     return 0;
54182   }
54183   std::string arg3_str(jarg3);
54184   arg3 = &arg3_str;
54185   {
54186     try {
54187       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3);
54188     } catch (std::out_of_range& e) {
54189       {
54190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54191       };
54192     } catch (std::exception& e) {
54193       {
54194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54195       };
54196     } catch (...) {
54197       {
54198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54199       };
54200     }
54201   }
54202   jresult = new Dali::Application((const Dali::Application &)result);
54203
54204   //argout typemap for const std::string&
54205
54206   return jresult;
54207 }
54208
54209
54210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_3(int jarg1, char * jarg3, int jarg4) {
54211   void * jresult ;
54212   int *arg1 = (int *) 0 ;
54213   char ***arg2 ;
54214   std::string *arg3 = 0 ;
54215   Dali::Application::WINDOW_MODE arg4 ;
54216   Dali::Application result;
54217
54218   {
54219     // Todo generate argv data from the C# args
54220     char **array;         // two dimensional array
54221     int numStrings = 1;     // number of strings
54222     int stringLength = 30;      // max string length.
54223     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
54224     argV = array;
54225
54226     // allocate the string data
54227     for( int i=0; i < numStrings; i++)
54228     {
54229       array[i]=(char *)malloc( stringLength * sizeof(char *) );
54230     }
54231     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
54232
54233     strcpy( array[0], "dali-csharp-app");
54234
54235     arg1 = &argC;
54236     arg2 = &argV;
54237   }
54238   if (!jarg3) {
54239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54240     return 0;
54241   }
54242   std::string arg3_str(jarg3);
54243   arg3 = &arg3_str;
54244   arg4 = (Dali::Application::WINDOW_MODE)jarg4;
54245   {
54246     try {
54247       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3,arg4);
54248     } catch (std::out_of_range& e) {
54249       {
54250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54251       };
54252     } catch (std::exception& e) {
54253       {
54254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54255       };
54256     } catch (...) {
54257       {
54258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54259       };
54260     }
54261   }
54262   jresult = new Dali::Application((const Dali::Application &)result);
54263
54264   //argout typemap for const std::string&
54265
54266   return jresult;
54267 }
54268
54269
54270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_0() {
54271   void * jresult ;
54272   Dali::Application *result = 0 ;
54273
54274   {
54275     try {
54276       result = (Dali::Application *)new Dali::Application();
54277     } catch (std::out_of_range& e) {
54278       {
54279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54280       };
54281     } catch (std::exception& e) {
54282       {
54283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54284       };
54285     } catch (...) {
54286       {
54287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54288       };
54289     }
54290   }
54291   jresult = (void *)result;
54292   return jresult;
54293 }
54294
54295
54296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_1(void * jarg1) {
54297   void * jresult ;
54298   Dali::Application *arg1 = 0 ;
54299   Dali::Application *result = 0 ;
54300
54301   arg1 = (Dali::Application *)jarg1;
54302   if (!arg1) {
54303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
54304     return 0;
54305   }
54306   {
54307     try {
54308       result = (Dali::Application *)new Dali::Application((Dali::Application const &)*arg1);
54309     } catch (std::out_of_range& e) {
54310       {
54311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54312       };
54313     } catch (std::exception& e) {
54314       {
54315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54316       };
54317     } catch (...) {
54318       {
54319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54320       };
54321     }
54322   }
54323   jresult = (void *)result;
54324   return jresult;
54325 }
54326
54327
54328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_Assign(void * jarg1, void * jarg2) {
54329   void * jresult ;
54330   Dali::Application *arg1 = (Dali::Application *) 0 ;
54331   Dali::Application *arg2 = 0 ;
54332   Dali::Application *result = 0 ;
54333
54334   arg1 = (Dali::Application *)jarg1;
54335   arg2 = (Dali::Application *)jarg2;
54336   if (!arg2) {
54337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
54338     return 0;
54339   }
54340   {
54341     try {
54342       result = (Dali::Application *) &(arg1)->operator =((Dali::Application const &)*arg2);
54343     } catch (std::out_of_range& e) {
54344       {
54345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54346       };
54347     } catch (std::exception& e) {
54348       {
54349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54350       };
54351     } catch (...) {
54352       {
54353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54354       };
54355     }
54356   }
54357   jresult = (void *)result;
54358   return jresult;
54359 }
54360
54361
54362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Application(void * jarg1) {
54363   Dali::Application *arg1 = (Dali::Application *) 0 ;
54364
54365   arg1 = (Dali::Application *)jarg1;
54366   {
54367     try {
54368       delete arg1;
54369     } catch (std::out_of_range& e) {
54370       {
54371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54372       };
54373     } catch (std::exception& e) {
54374       {
54375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54376       };
54377     } catch (...) {
54378       {
54379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54380       };
54381     }
54382   }
54383 }
54384
54385
54386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_0(void * jarg1) {
54387   Dali::Application *arg1 = (Dali::Application *) 0 ;
54388
54389   arg1 = (Dali::Application *)jarg1;
54390   {
54391     try {
54392       (arg1)->MainLoop();
54393     } catch (std::out_of_range& e) {
54394       {
54395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54396       };
54397     } catch (std::exception& e) {
54398       {
54399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54400       };
54401     } catch (...) {
54402       {
54403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54404       };
54405     }
54406   }
54407 }
54408
54409
54410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_1(void * jarg1, void * jarg2) {
54411   Dali::Application *arg1 = (Dali::Application *) 0 ;
54412   Configuration::ContextLoss arg2 ;
54413   Configuration::ContextLoss *argp2 ;
54414
54415   arg1 = (Dali::Application *)jarg1;
54416   argp2 = (Configuration::ContextLoss *)jarg2;
54417   if (!argp2) {
54418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Configuration::ContextLoss", 0);
54419     return ;
54420   }
54421   arg2 = *argp2;
54422   {
54423     try {
54424       (arg1)->MainLoop(arg2);
54425     } catch (std::out_of_range& e) {
54426       {
54427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54428       };
54429     } catch (std::exception& e) {
54430       {
54431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54432       };
54433     } catch (...) {
54434       {
54435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54436       };
54437     }
54438   }
54439 }
54440
54441
54442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Lower(void * jarg1) {
54443   Dali::Application *arg1 = (Dali::Application *) 0 ;
54444
54445   arg1 = (Dali::Application *)jarg1;
54446   {
54447     try {
54448       (arg1)->Lower();
54449     } catch (std::out_of_range& e) {
54450       {
54451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54452       };
54453     } catch (std::exception& e) {
54454       {
54455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54456       };
54457     } catch (...) {
54458       {
54459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54460       };
54461     }
54462   }
54463 }
54464
54465
54466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Quit(void * jarg1) {
54467   Dali::Application *arg1 = (Dali::Application *) 0 ;
54468
54469   arg1 = (Dali::Application *)jarg1;
54470   {
54471     try {
54472       (arg1)->Quit();
54473     } catch (std::out_of_range& e) {
54474       {
54475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54476       };
54477     } catch (std::exception& e) {
54478       {
54479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54480       };
54481     } catch (...) {
54482       {
54483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54484       };
54485     }
54486   }
54487 }
54488
54489
54490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_AddIdle(void * jarg1, void * jarg2) {
54491   unsigned int jresult ;
54492   Dali::Application *arg1 = (Dali::Application *) 0 ;
54493   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
54494   bool result;
54495
54496   arg1 = (Dali::Application *)jarg1;
54497   arg2 = (Dali::CallbackBase *)jarg2;
54498   {
54499     try {
54500       result = (bool)(arg1)->AddIdle(arg2);
54501     } catch (std::out_of_range& e) {
54502       {
54503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54504       };
54505     } catch (std::exception& e) {
54506       {
54507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54508       };
54509     } catch (...) {
54510       {
54511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54512       };
54513     }
54514   }
54515   jresult = result;
54516   return jresult;
54517 }
54518
54519
54520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_GetWindow(void * jarg1) {
54521   void * jresult ;
54522   Dali::Application *arg1 = (Dali::Application *) 0 ;
54523   Dali::Window result;
54524
54525   arg1 = (Dali::Application *)jarg1;
54526   {
54527     try {
54528       result = (arg1)->GetWindow();
54529     } catch (std::out_of_range& e) {
54530       {
54531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54532       };
54533     } catch (std::exception& e) {
54534       {
54535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54536       };
54537     } catch (...) {
54538       {
54539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54540       };
54541     }
54542   }
54543   jresult = new Dali::Window((const Dali::Window &)result);
54544   return jresult;
54545 }
54546
54547
54548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_ReplaceWindow(void * jarg1, void * jarg2, char * jarg3) {
54549   Dali::Application *arg1 = (Dali::Application *) 0 ;
54550   Dali::PositionSize arg2 ;
54551   std::string *arg3 = 0 ;
54552   Dali::PositionSize *argp2 ;
54553
54554   arg1 = (Dali::Application *)jarg1;
54555   argp2 = (Dali::PositionSize *)jarg2;
54556   if (!argp2) {
54557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
54558     return ;
54559   }
54560   arg2 = *argp2;
54561   if (!jarg3) {
54562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54563     return ;
54564   }
54565   std::string arg3_str(jarg3);
54566   arg3 = &arg3_str;
54567   {
54568     try {
54569       (arg1)->ReplaceWindow(arg2,(std::string const &)*arg3);
54570     } catch (std::out_of_range& e) {
54571       {
54572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54573       };
54574     } catch (std::exception& e) {
54575       {
54576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54577       };
54578     } catch (...) {
54579       {
54580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54581       };
54582     }
54583   }
54584
54585   //argout typemap for const std::string&
54586
54587 }
54588
54589
54590 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Application_GetResourcePath() {
54591   char * jresult ;
54592   std::string result;
54593
54594   {
54595     try {
54596       result = Dali::Application::GetResourcePath();
54597     } catch (std::out_of_range& e) {
54598       {
54599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54600       };
54601     } catch (std::exception& e) {
54602       {
54603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54604       };
54605     } catch (...) {
54606       {
54607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54608       };
54609     }
54610   }
54611   jresult = SWIG_csharp_string_callback((&result)->c_str());
54612   return jresult;
54613 }
54614
54615
54616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetViewMode(void * jarg1, int jarg2) {
54617   Dali::Application *arg1 = (Dali::Application *) 0 ;
54618   Dali::ViewMode arg2 ;
54619
54620   arg1 = (Dali::Application *)jarg1;
54621   arg2 = (Dali::ViewMode)jarg2;
54622   {
54623     try {
54624       (arg1)->SetViewMode(arg2);
54625     } catch (std::out_of_range& e) {
54626       {
54627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54628       };
54629     } catch (std::exception& e) {
54630       {
54631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54632       };
54633     } catch (...) {
54634       {
54635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54636       };
54637     }
54638   }
54639 }
54640
54641
54642 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Application_GetViewMode(void * jarg1) {
54643   int jresult ;
54644   Dali::Application *arg1 = (Dali::Application *) 0 ;
54645   Dali::ViewMode result;
54646
54647   arg1 = (Dali::Application *)jarg1;
54648   {
54649     try {
54650       result = (Dali::ViewMode)((Dali::Application const *)arg1)->GetViewMode();
54651     } catch (std::out_of_range& e) {
54652       {
54653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54654       };
54655     } catch (std::exception& e) {
54656       {
54657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54658       };
54659     } catch (...) {
54660       {
54661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54662       };
54663     }
54664   }
54665   jresult = (int)result;
54666   return jresult;
54667 }
54668
54669
54670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetStereoBase(void * jarg1, float jarg2) {
54671   Dali::Application *arg1 = (Dali::Application *) 0 ;
54672   float arg2 ;
54673
54674   arg1 = (Dali::Application *)jarg1;
54675   arg2 = (float)jarg2;
54676   {
54677     try {
54678       (arg1)->SetStereoBase(arg2);
54679     } catch (std::out_of_range& e) {
54680       {
54681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54682       };
54683     } catch (std::exception& e) {
54684       {
54685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54686       };
54687     } catch (...) {
54688       {
54689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54690       };
54691     }
54692   }
54693 }
54694
54695
54696 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Application_GetStereoBase(void * jarg1) {
54697   float jresult ;
54698   Dali::Application *arg1 = (Dali::Application *) 0 ;
54699   float result;
54700
54701   arg1 = (Dali::Application *)jarg1;
54702   {
54703     try {
54704       result = (float)((Dali::Application const *)arg1)->GetStereoBase();
54705     } catch (std::out_of_range& e) {
54706       {
54707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54708       };
54709     } catch (std::exception& e) {
54710       {
54711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54712       };
54713     } catch (...) {
54714       {
54715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54716       };
54717     }
54718   }
54719   jresult = result;
54720   return jresult;
54721 }
54722
54723
54724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_InitSignal(void * jarg1) {
54725   void * jresult ;
54726   Dali::Application *arg1 = (Dali::Application *) 0 ;
54727   Dali::Application::AppSignalType *result = 0 ;
54728
54729   arg1 = (Dali::Application *)jarg1;
54730   {
54731     try {
54732       result = (Dali::Application::AppSignalType *) &(arg1)->InitSignal();
54733     } catch (std::out_of_range& e) {
54734       {
54735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54736       };
54737     } catch (std::exception& e) {
54738       {
54739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54740       };
54741     } catch (...) {
54742       {
54743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54744       };
54745     }
54746   }
54747   jresult = (void *)result;
54748   return jresult;
54749 }
54750
54751
54752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_TerminateSignal(void * jarg1) {
54753   void * jresult ;
54754   Dali::Application *arg1 = (Dali::Application *) 0 ;
54755   Dali::Application::AppSignalType *result = 0 ;
54756
54757   arg1 = (Dali::Application *)jarg1;
54758   {
54759     try {
54760       result = (Dali::Application::AppSignalType *) &(arg1)->TerminateSignal();
54761     } catch (std::out_of_range& e) {
54762       {
54763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54764       };
54765     } catch (std::exception& e) {
54766       {
54767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54768       };
54769     } catch (...) {
54770       {
54771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54772       };
54773     }
54774   }
54775   jresult = (void *)result;
54776   return jresult;
54777 }
54778
54779
54780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_PauseSignal(void * jarg1) {
54781   void * jresult ;
54782   Dali::Application *arg1 = (Dali::Application *) 0 ;
54783   Dali::Application::AppSignalType *result = 0 ;
54784
54785   arg1 = (Dali::Application *)jarg1;
54786   {
54787     try {
54788       result = (Dali::Application::AppSignalType *) &(arg1)->PauseSignal();
54789     } catch (std::out_of_range& e) {
54790       {
54791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54792       };
54793     } catch (std::exception& e) {
54794       {
54795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54796       };
54797     } catch (...) {
54798       {
54799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54800       };
54801     }
54802   }
54803   jresult = (void *)result;
54804   return jresult;
54805 }
54806
54807
54808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResumeSignal(void * jarg1) {
54809   void * jresult ;
54810   Dali::Application *arg1 = (Dali::Application *) 0 ;
54811   Dali::Application::AppSignalType *result = 0 ;
54812
54813   arg1 = (Dali::Application *)jarg1;
54814   {
54815     try {
54816       result = (Dali::Application::AppSignalType *) &(arg1)->ResumeSignal();
54817     } catch (std::out_of_range& e) {
54818       {
54819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54820       };
54821     } catch (std::exception& e) {
54822       {
54823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54824       };
54825     } catch (...) {
54826       {
54827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54828       };
54829     }
54830   }
54831   jresult = (void *)result;
54832   return jresult;
54833 }
54834
54835
54836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResetSignal(void * jarg1) {
54837   void * jresult ;
54838   Dali::Application *arg1 = (Dali::Application *) 0 ;
54839   Dali::Application::AppSignalType *result = 0 ;
54840
54841   arg1 = (Dali::Application *)jarg1;
54842   {
54843     try {
54844       result = (Dali::Application::AppSignalType *) &(arg1)->ResetSignal();
54845     } catch (std::out_of_range& e) {
54846       {
54847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54848       };
54849     } catch (std::exception& e) {
54850       {
54851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54852       };
54853     } catch (...) {
54854       {
54855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54856       };
54857     }
54858   }
54859   jresult = (void *)result;
54860   return jresult;
54861 }
54862
54863
54864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResizeSignal(void * jarg1) {
54865   void * jresult ;
54866   Dali::Application *arg1 = (Dali::Application *) 0 ;
54867   Dali::Application::AppSignalType *result = 0 ;
54868
54869   arg1 = (Dali::Application *)jarg1;
54870   {
54871     try {
54872       result = (Dali::Application::AppSignalType *) &(arg1)->ResizeSignal();
54873     } catch (std::out_of_range& e) {
54874       {
54875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54876       };
54877     } catch (std::exception& e) {
54878       {
54879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54880       };
54881     } catch (...) {
54882       {
54883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54884       };
54885     }
54886   }
54887   jresult = (void *)result;
54888   return jresult;
54889 }
54890
54891
54892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_AppControlSignal(void * jarg1) {
54893   void * jresult ;
54894   Dali::Application *arg1 = (Dali::Application *) 0 ;
54895   Dali::Application::AppControlSignalType *result = 0 ;
54896
54897   arg1 = (Dali::Application *)jarg1;
54898   {
54899     try {
54900       result = (Dali::Application::AppControlSignalType *) &(arg1)->AppControlSignal();
54901     } catch (std::out_of_range& e) {
54902       {
54903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54904       };
54905     } catch (std::exception& e) {
54906       {
54907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54908       };
54909     } catch (...) {
54910       {
54911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54912       };
54913     }
54914   }
54915   jresult = (void *)result;
54916   return jresult;
54917 }
54918
54919
54920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_LanguageChangedSignal(void * jarg1) {
54921   void * jresult ;
54922   Dali::Application *arg1 = (Dali::Application *) 0 ;
54923   Dali::Application::AppSignalType *result = 0 ;
54924
54925   arg1 = (Dali::Application *)jarg1;
54926   {
54927     try {
54928       result = (Dali::Application::AppSignalType *) &(arg1)->LanguageChangedSignal();
54929     } catch (std::out_of_range& e) {
54930       {
54931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54932       };
54933     } catch (std::exception& e) {
54934       {
54935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54936       };
54937     } catch (...) {
54938       {
54939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54940       };
54941     }
54942   }
54943   jresult = (void *)result;
54944   return jresult;
54945 }
54946
54947
54948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_RegionChangedSignal(void * jarg1) {
54949   void * jresult ;
54950   Dali::Application *arg1 = (Dali::Application *) 0 ;
54951   Dali::Application::AppSignalType *result = 0 ;
54952
54953   arg1 = (Dali::Application *)jarg1;
54954   {
54955     try {
54956       result = (Dali::Application::AppSignalType *) &(arg1)->RegionChangedSignal();
54957     } catch (std::out_of_range& e) {
54958       {
54959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54960       };
54961     } catch (std::exception& e) {
54962       {
54963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54964       };
54965     } catch (...) {
54966       {
54967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54968       };
54969     }
54970   }
54971   jresult = (void *)result;
54972   return jresult;
54973 }
54974
54975
54976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_BatteryLowSignal(void * jarg1) {
54977   void * jresult ;
54978   Dali::Application *arg1 = (Dali::Application *) 0 ;
54979   Dali::Application::AppSignalType *result = 0 ;
54980
54981   arg1 = (Dali::Application *)jarg1;
54982   {
54983     try {
54984       result = (Dali::Application::AppSignalType *) &(arg1)->BatteryLowSignal();
54985     } catch (std::out_of_range& e) {
54986       {
54987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54988       };
54989     } catch (std::exception& e) {
54990       {
54991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54992       };
54993     } catch (...) {
54994       {
54995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54996       };
54997     }
54998   }
54999   jresult = (void *)result;
55000   return jresult;
55001 }
55002
55003
55004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_MemoryLowSignal(void * jarg1) {
55005   void * jresult ;
55006   Dali::Application *arg1 = (Dali::Application *) 0 ;
55007   Dali::Application::AppSignalType *result = 0 ;
55008
55009   arg1 = (Dali::Application *)jarg1;
55010   {
55011     try {
55012       result = (Dali::Application::AppSignalType *) &(arg1)->MemoryLowSignal();
55013     } catch (std::out_of_range& e) {
55014       {
55015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55016       };
55017     } catch (std::exception& e) {
55018       {
55019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55020       };
55021     } catch (...) {
55022       {
55023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55024       };
55025     }
55026   }
55027   jresult = (void *)result;
55028   return jresult;
55029 }
55030
55031
55032 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationSignal_Empty(void * jarg1) {
55033   unsigned int jresult ;
55034   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55035   bool result;
55036
55037   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55038   {
55039     try {
55040       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Application &) > const *)arg1);
55041     } catch (std::out_of_range& e) {
55042       {
55043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55044       };
55045     } catch (std::exception& e) {
55046       {
55047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55048       };
55049     } catch (...) {
55050       {
55051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55052       };
55053     }
55054   }
55055   jresult = result;
55056   return jresult;
55057 }
55058
55059
55060 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationSignal_GetConnectionCount(void * jarg1) {
55061   unsigned long jresult ;
55062   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55063   std::size_t result;
55064
55065   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55066   {
55067     try {
55068       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &) > const *)arg1);
55069     } catch (std::out_of_range& e) {
55070       {
55071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55072       };
55073     } catch (std::exception& e) {
55074       {
55075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55076       };
55077     } catch (...) {
55078       {
55079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55080       };
55081     }
55082   }
55083   jresult = (unsigned long)result;
55084   return jresult;
55085 }
55086
55087
55088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Connect(void * jarg1, void * jarg2) {
55089   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55090   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
55091
55092   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55093   arg2 = (void (*)(Dali::Application &))jarg2;
55094   {
55095     try {
55096       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(arg1,arg2);
55097     } catch (std::out_of_range& e) {
55098       {
55099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55100       };
55101     } catch (std::exception& e) {
55102       {
55103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55104       };
55105     } catch (...) {
55106       {
55107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55108       };
55109     }
55110   }
55111 }
55112
55113
55114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Disconnect(void * jarg1, void * jarg2) {
55115   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55116   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
55117
55118   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55119   arg2 = (void (*)(Dali::Application &))jarg2;
55120   {
55121     try {
55122       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(arg1,arg2);
55123     } catch (std::out_of_range& e) {
55124       {
55125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55126       };
55127     } catch (std::exception& e) {
55128       {
55129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55130       };
55131     } catch (...) {
55132       {
55133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55134       };
55135     }
55136   }
55137 }
55138
55139
55140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Emit(void * jarg1, void * jarg2) {
55141   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55142   Dali::Application *arg2 = 0 ;
55143
55144   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55145   arg2 = (Dali::Application *)jarg2;
55146   if (!arg2) {
55147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
55148     return ;
55149   }
55150   {
55151     try {
55152       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(arg1,*arg2);
55153     } catch (std::out_of_range& e) {
55154       {
55155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55156       };
55157     } catch (std::exception& e) {
55158       {
55159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55160       };
55161     } catch (...) {
55162       {
55163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55164       };
55165     }
55166   }
55167 }
55168
55169
55170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationSignal() {
55171   void * jresult ;
55172   Dali::Signal< void (Dali::Application &) > *result = 0 ;
55173
55174   {
55175     try {
55176       result = (Dali::Signal< void (Dali::Application &) > *)new Dali::Signal< void (Dali::Application &) >();
55177     } catch (std::out_of_range& e) {
55178       {
55179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55180       };
55181     } catch (std::exception& e) {
55182       {
55183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55184       };
55185     } catch (...) {
55186       {
55187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55188       };
55189     }
55190   }
55191   jresult = (void *)result;
55192   return jresult;
55193 }
55194
55195
55196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationSignal(void * jarg1) {
55197   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55198
55199   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55200   {
55201     try {
55202       delete arg1;
55203     } catch (std::out_of_range& e) {
55204       {
55205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55206       };
55207     } catch (std::exception& e) {
55208       {
55209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55210       };
55211     } catch (...) {
55212       {
55213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55214       };
55215     }
55216   }
55217 }
55218
55219
55220 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Empty(void * jarg1) {
55221   unsigned int jresult ;
55222   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55223   bool result;
55224
55225   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55226   {
55227     try {
55228       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
55229     } catch (std::out_of_range& e) {
55230       {
55231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55232       };
55233     } catch (std::exception& e) {
55234       {
55235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55236       };
55237     } catch (...) {
55238       {
55239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55240       };
55241     }
55242   }
55243   jresult = result;
55244   return jresult;
55245 }
55246
55247
55248 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_GetConnectionCount(void * jarg1) {
55249   unsigned long jresult ;
55250   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55251   std::size_t result;
55252
55253   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55254   {
55255     try {
55256       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
55257     } catch (std::out_of_range& e) {
55258       {
55259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55260       };
55261     } catch (std::exception& e) {
55262       {
55263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55264       };
55265     } catch (...) {
55266       {
55267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55268       };
55269     }
55270   }
55271   jresult = (unsigned long)result;
55272   return jresult;
55273 }
55274
55275
55276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Connect(void * jarg1, void * jarg2) {
55277   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55278   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
55279
55280   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55281   arg2 = (void (*)(Dali::Application &,void *))jarg2;
55282   {
55283     try {
55284       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(arg1,arg2);
55285     } catch (std::out_of_range& e) {
55286       {
55287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55288       };
55289     } catch (std::exception& e) {
55290       {
55291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55292       };
55293     } catch (...) {
55294       {
55295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55296       };
55297     }
55298   }
55299 }
55300
55301
55302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Disconnect(void * jarg1, void * jarg2) {
55303   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55304   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
55305
55306   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55307   arg2 = (void (*)(Dali::Application &,void *))jarg2;
55308   {
55309     try {
55310       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(arg1,arg2);
55311     } catch (std::out_of_range& e) {
55312       {
55313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55314       };
55315     } catch (std::exception& e) {
55316       {
55317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55318       };
55319     } catch (...) {
55320       {
55321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55322       };
55323     }
55324   }
55325 }
55326
55327
55328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55329   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55330   Dali::Application *arg2 = 0 ;
55331   void *arg3 = (void *) 0 ;
55332
55333   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55334   arg2 = (Dali::Application *)jarg2;
55335   if (!arg2) {
55336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
55337     return ;
55338   }
55339   arg3 = jarg3;
55340   {
55341     try {
55342       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(arg1,*arg2,arg3);
55343     } catch (std::out_of_range& e) {
55344       {
55345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55346       };
55347     } catch (std::exception& e) {
55348       {
55349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55350       };
55351     } catch (...) {
55352       {
55353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55354       };
55355     }
55356   }
55357 }
55358
55359
55360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationControlSignal() {
55361   void * jresult ;
55362   Dali::Signal< void (Dali::Application &,void *) > *result = 0 ;
55363
55364   {
55365     try {
55366       result = (Dali::Signal< void (Dali::Application &,void *) > *)new Dali::Signal< void (Dali::Application &,void *) >();
55367     } catch (std::out_of_range& e) {
55368       {
55369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55370       };
55371     } catch (std::exception& e) {
55372       {
55373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55374       };
55375     } catch (...) {
55376       {
55377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55378       };
55379     }
55380   }
55381   jresult = (void *)result;
55382   return jresult;
55383 }
55384
55385
55386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationControlSignal(void * jarg1) {
55387   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55388
55389   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55390   {
55391     try {
55392       delete arg1;
55393     } catch (std::out_of_range& e) {
55394       {
55395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55396       };
55397     } catch (std::exception& e) {
55398       {
55399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55400       };
55401     } catch (...) {
55402       {
55403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55404       };
55405     }
55406   }
55407 }
55408
55409
55410 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
55411   unsigned int jresult ;
55412   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55413   bool result;
55414
55415   arg1 = (Dali::Signal< bool () > *)jarg1;
55416   {
55417     try {
55418       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
55419     } catch (std::out_of_range& e) {
55420       {
55421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55422       };
55423     } catch (std::exception& e) {
55424       {
55425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55426       };
55427     } catch (...) {
55428       {
55429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55430       };
55431     }
55432   }
55433   jresult = result;
55434   return jresult;
55435 }
55436
55437
55438 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
55439   unsigned long jresult ;
55440   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55441   std::size_t result;
55442
55443   arg1 = (Dali::Signal< bool () > *)jarg1;
55444   {
55445     try {
55446       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
55447     } catch (std::out_of_range& e) {
55448       {
55449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55450       };
55451     } catch (std::exception& e) {
55452       {
55453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55454       };
55455     } catch (...) {
55456       {
55457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55458       };
55459     }
55460   }
55461   jresult = (unsigned long)result;
55462   return jresult;
55463 }
55464
55465
55466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
55467   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55468   bool (*arg2)() = (bool (*)()) 0 ;
55469
55470   arg1 = (Dali::Signal< bool () > *)jarg1;
55471   arg2 = (bool (*)())jarg2;
55472   {
55473     try {
55474       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
55475     } catch (std::out_of_range& e) {
55476       {
55477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55478       };
55479     } catch (std::exception& e) {
55480       {
55481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55482       };
55483     } catch (...) {
55484       {
55485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55486       };
55487     }
55488   }
55489 }
55490
55491
55492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
55493   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55494   bool (*arg2)() = (bool (*)()) 0 ;
55495
55496   arg1 = (Dali::Signal< bool () > *)jarg1;
55497   arg2 = (bool (*)())jarg2;
55498   {
55499     try {
55500       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
55501     } catch (std::out_of_range& e) {
55502       {
55503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55504       };
55505     } catch (std::exception& e) {
55506       {
55507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55508       };
55509     } catch (...) {
55510       {
55511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55512       };
55513     }
55514   }
55515 }
55516
55517
55518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
55519   unsigned int jresult ;
55520   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55521   bool result;
55522
55523   arg1 = (Dali::Signal< bool () > *)jarg1;
55524   {
55525     try {
55526       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
55527     } catch (std::out_of_range& e) {
55528       {
55529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55530       };
55531     } catch (std::exception& e) {
55532       {
55533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55534       };
55535     } catch (...) {
55536       {
55537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55538       };
55539     }
55540   }
55541   jresult = result;
55542   return jresult;
55543 }
55544
55545
55546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
55547   void * jresult ;
55548   Dali::Signal< bool () > *result = 0 ;
55549
55550   {
55551     try {
55552       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
55553     } catch (std::out_of_range& e) {
55554       {
55555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55556       };
55557     } catch (std::exception& e) {
55558       {
55559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55560       };
55561     } catch (...) {
55562       {
55563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55564       };
55565     }
55566   }
55567   jresult = (void *)result;
55568   return jresult;
55569 }
55570
55571
55572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
55573   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55574
55575   arg1 = (Dali::Signal< bool () > *)jarg1;
55576   {
55577     try {
55578       delete arg1;
55579     } catch (std::out_of_range& e) {
55580       {
55581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55582       };
55583     } catch (std::exception& e) {
55584       {
55585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55586       };
55587     } catch (...) {
55588       {
55589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55590       };
55591     }
55592   }
55593 }
55594
55595
55596
55597
55598
55599 //manual merge 2017-03-31
55600 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Empty(void * jarg1) {
55601   unsigned int jresult ;
55602   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55603   bool result;
55604
55605   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55606   {
55607     try {
55608       result = (bool)Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty((Dali::Signal< void (bool) > const *)arg1);
55609     } catch (std::out_of_range& e) {
55610       {
55611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55612       };
55613     } catch (std::exception& e) {
55614       {
55615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55616       };
55617     } catch (...) {
55618       {
55619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55620       };
55621     }
55622   }
55623   jresult = result;
55624   return jresult;
55625 }
55626
55627
55628 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_GetConnectionCount(void * jarg1) {
55629   unsigned long jresult ;
55630   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55631   std::size_t result;
55632
55633   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55634   {
55635     try {
55636       result = Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (bool) > const *)arg1);
55637     } catch (std::out_of_range& e) {
55638       {
55639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55640       };
55641     } catch (std::exception& e) {
55642       {
55643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55644       };
55645     } catch (...) {
55646       {
55647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55648       };
55649     }
55650   }
55651   jresult = (unsigned long)result;
55652   return jresult;
55653 }
55654
55655
55656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Connect(void * jarg1, void * jarg2) {
55657   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55658   void (*arg2)(bool) = (void (*)(bool)) 0 ;
55659
55660   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55661   arg2 = (void (*)(bool))jarg2;
55662   {
55663     try {
55664       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(arg1,arg2);
55665     } catch (std::out_of_range& e) {
55666       {
55667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55668       };
55669     } catch (std::exception& e) {
55670       {
55671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55672       };
55673     } catch (...) {
55674       {
55675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55676       };
55677     }
55678   }
55679 }
55680
55681
55682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Disconnect(void * jarg1, void * jarg2) {
55683   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55684   void (*arg2)(bool) = (void (*)(bool)) 0 ;
55685
55686   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55687   arg2 = (void (*)(bool))jarg2;
55688   {
55689     try {
55690       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(arg1,arg2);
55691     } catch (std::out_of_range& e) {
55692       {
55693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55694       };
55695     } catch (std::exception& e) {
55696       {
55697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55698       };
55699     } catch (...) {
55700       {
55701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55702       };
55703     }
55704   }
55705 }
55706
55707
55708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Emit(void * jarg1, unsigned int jarg2) {
55709   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55710   bool arg2 ;
55711
55712   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55713   arg2 = jarg2 ? true : false;
55714   {
55715     try {
55716       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(arg1,arg2);
55717     } catch (std::out_of_range& e) {
55718       {
55719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55720       };
55721     } catch (std::exception& e) {
55722       {
55723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55724       };
55725     } catch (...) {
55726       {
55727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55728       };
55729     }
55730   }
55731 }
55732
55733
55734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WindowFocusSignalType() {
55735   void * jresult ;
55736   Dali::Signal< void (bool) > *result = 0 ;
55737
55738   {
55739     try {
55740       result = (Dali::Signal< void (bool) > *)new Dali::Signal< void (bool) >();
55741     } catch (std::out_of_range& e) {
55742       {
55743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55744       };
55745     } catch (std::exception& e) {
55746       {
55747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55748       };
55749     } catch (...) {
55750       {
55751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55752       };
55753     }
55754   }
55755   jresult = (void *)result;
55756   return jresult;
55757 }
55758
55759
55760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WindowFocusSignalType(void * jarg1) {
55761   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55762
55763   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55764   {
55765     try {
55766       delete arg1;
55767     } catch (std::out_of_range& e) {
55768       {
55769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55770       };
55771     } catch (std::exception& e) {
55772       {
55773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55774       };
55775     } catch (...) {
55776       {
55777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55778       };
55779     }
55780   }
55781 }
55782
55783
55784
55785
55786
55787
55788 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
55789   int jresult ;
55790   int result;
55791
55792   {
55793     try {
55794       result = (int)Dali::Toolkit::Visual::Property::TYPE;
55795     } catch (std::out_of_range& e) {
55796       {
55797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55798       };
55799     } catch (std::exception& e) {
55800       {
55801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55802       };
55803     } catch (...) {
55804       {
55805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55806       };
55807     }
55808   }
55809   jresult = (int)result;
55810   return jresult;
55811 }
55812
55813
55814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
55815   int jresult ;
55816   int result;
55817
55818   {
55819     try {
55820       result = (int)Dali::Toolkit::Visual::Property::SHADER;
55821     } catch (std::out_of_range& e) {
55822       {
55823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55824       };
55825     } catch (std::exception& e) {
55826       {
55827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55828       };
55829     } catch (...) {
55830       {
55831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55832       };
55833     }
55834   }
55835   jresult = (int)result;
55836   return jresult;
55837 }
55838
55839
55840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
55841   int jresult ;
55842   int result;
55843
55844   {
55845     try {
55846       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
55847     } catch (std::out_of_range& e) {
55848       {
55849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55850       };
55851     } catch (std::exception& e) {
55852       {
55853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55854       };
55855     } catch (...) {
55856       {
55857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55858       };
55859     }
55860   }
55861   jresult = (int)result;
55862   return jresult;
55863 }
55864
55865
55866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
55867   int jresult ;
55868   int result;
55869
55870   {
55871     try {
55872       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
55873     } catch (std::out_of_range& e) {
55874       {
55875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55876       };
55877     } catch (std::exception& e) {
55878       {
55879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55880       };
55881     } catch (...) {
55882       {
55883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55884       };
55885     }
55886   }
55887   jresult = (int)result;
55888   return jresult;
55889 }
55890
55891
55892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
55893   int jresult ;
55894   int result;
55895
55896   {
55897     try {
55898       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
55899     } catch (std::out_of_range& e) {
55900       {
55901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55902       };
55903     } catch (std::exception& e) {
55904       {
55905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55906       };
55907     } catch (...) {
55908       {
55909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55910       };
55911     }
55912   }
55913   jresult = (int)result;
55914   return jresult;
55915 }
55916
55917
55918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
55919   int jresult ;
55920   int result;
55921
55922   {
55923     try {
55924       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
55925     } catch (std::out_of_range& e) {
55926       {
55927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55928       };
55929     } catch (std::exception& e) {
55930       {
55931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55932       };
55933     } catch (...) {
55934       {
55935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55936       };
55937     }
55938   }
55939   jresult = (int)result;
55940   return jresult;
55941 }
55942
55943
55944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
55945   int jresult ;
55946   int result;
55947
55948   {
55949     try {
55950       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
55951     } catch (std::out_of_range& e) {
55952       {
55953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55954       };
55955     } catch (std::exception& e) {
55956       {
55957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55958       };
55959     } catch (...) {
55960       {
55961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55962       };
55963     }
55964   }
55965   jresult = (int)result;
55966   return jresult;
55967 }
55968
55969
55970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
55971   int jresult ;
55972   int result;
55973
55974   {
55975     try {
55976       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
55977     } catch (std::out_of_range& e) {
55978       {
55979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55980       };
55981     } catch (std::exception& e) {
55982       {
55983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55984       };
55985     } catch (...) {
55986       {
55987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55988       };
55989     }
55990   }
55991   jresult = (int)result;
55992   return jresult;
55993 }
55994
55995
55996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
55997   int jresult ;
55998   int result;
55999
56000   {
56001     try {
56002       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
56003     } catch (std::out_of_range& e) {
56004       {
56005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56006       };
56007     } catch (std::exception& e) {
56008       {
56009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56010       };
56011     } catch (...) {
56012       {
56013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56014       };
56015     }
56016   }
56017   jresult = (int)result;
56018   return jresult;
56019 }
56020
56021
56022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
56023   int jresult ;
56024   int result;
56025
56026   {
56027     try {
56028       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
56029     } catch (std::out_of_range& e) {
56030       {
56031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56032       };
56033     } catch (std::exception& e) {
56034       {
56035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56036       };
56037     } catch (...) {
56038       {
56039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56040       };
56041     }
56042   }
56043   jresult = (int)result;
56044   return jresult;
56045 }
56046
56047
56048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
56049   int jresult ;
56050   int result;
56051
56052   {
56053     try {
56054       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
56055     } catch (std::out_of_range& e) {
56056       {
56057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56058       };
56059     } catch (std::exception& e) {
56060       {
56061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56062       };
56063     } catch (...) {
56064       {
56065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56066       };
56067     }
56068   }
56069   jresult = (int)result;
56070   return jresult;
56071 }
56072
56073
56074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
56075   int jresult ;
56076   int result;
56077
56078   {
56079     try {
56080       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
56081     } catch (std::out_of_range& e) {
56082       {
56083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56084       };
56085     } catch (std::exception& e) {
56086       {
56087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56088       };
56089     } catch (...) {
56090       {
56091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56092       };
56093     }
56094   }
56095   jresult = (int)result;
56096   return jresult;
56097 }
56098
56099
56100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
56101   int jresult ;
56102   int result;
56103
56104   {
56105     try {
56106       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
56107     } catch (std::out_of_range& e) {
56108       {
56109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56110       };
56111     } catch (std::exception& e) {
56112       {
56113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56114       };
56115     } catch (...) {
56116       {
56117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56118       };
56119     }
56120   }
56121   jresult = (int)result;
56122   return jresult;
56123 }
56124
56125
56126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
56127   int jresult ;
56128   int result;
56129
56130   {
56131     try {
56132       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
56133     } catch (std::out_of_range& e) {
56134       {
56135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56136       };
56137     } catch (std::exception& e) {
56138       {
56139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56140       };
56141     } catch (...) {
56142       {
56143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56144       };
56145     }
56146   }
56147   jresult = (int)result;
56148   return jresult;
56149 }
56150
56151
56152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
56153   int jresult ;
56154   int result;
56155
56156   {
56157     try {
56158       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
56159     } catch (std::out_of_range& e) {
56160       {
56161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56162       };
56163     } catch (std::exception& e) {
56164       {
56165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56166       };
56167     } catch (...) {
56168       {
56169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56170       };
56171     }
56172   }
56173   jresult = (int)result;
56174   return jresult;
56175 }
56176
56177
56178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
56179   int jresult ;
56180   int result;
56181
56182   {
56183     try {
56184       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
56185     } catch (std::out_of_range& e) {
56186       {
56187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56188       };
56189     } catch (std::exception& e) {
56190       {
56191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56192       };
56193     } catch (...) {
56194       {
56195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56196       };
56197     }
56198   }
56199   jresult = (int)result;
56200   return jresult;
56201 }
56202
56203
56204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
56205   int jresult ;
56206   int result;
56207
56208   {
56209     try {
56210       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
56211     } catch (std::out_of_range& e) {
56212       {
56213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56214       };
56215     } catch (std::exception& e) {
56216       {
56217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56218       };
56219     } catch (...) {
56220       {
56221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56222       };
56223     }
56224   }
56225   jresult = (int)result;
56226   return jresult;
56227 }
56228
56229
56230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
56231   int jresult ;
56232   int result;
56233
56234   {
56235     try {
56236       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
56237     } catch (std::out_of_range& e) {
56238       {
56239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56240       };
56241     } catch (std::exception& e) {
56242       {
56243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56244       };
56245     } catch (...) {
56246       {
56247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56248       };
56249     }
56250   }
56251   jresult = (int)result;
56252   return jresult;
56253 }
56254
56255
56256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
56257   int jresult ;
56258   int result;
56259
56260   {
56261     try {
56262       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
56263     } catch (std::out_of_range& e) {
56264       {
56265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56266       };
56267     } catch (std::exception& e) {
56268       {
56269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56270       };
56271     } catch (...) {
56272       {
56273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56274       };
56275     }
56276   }
56277   jresult = (int)result;
56278   return jresult;
56279 }
56280
56281
56282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
56283   int jresult ;
56284   int result;
56285
56286   {
56287     try {
56288       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
56289     } catch (std::out_of_range& e) {
56290       {
56291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56292       };
56293     } catch (std::exception& e) {
56294       {
56295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56296       };
56297     } catch (...) {
56298       {
56299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56300       };
56301     }
56302   }
56303   jresult = (int)result;
56304   return jresult;
56305 }
56306
56307
56308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
56309   int jresult ;
56310   int result;
56311
56312   {
56313     try {
56314       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
56315     } catch (std::out_of_range& e) {
56316       {
56317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56318       };
56319     } catch (std::exception& e) {
56320       {
56321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56322       };
56323     } catch (...) {
56324       {
56325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56326       };
56327     }
56328   }
56329   jresult = (int)result;
56330   return jresult;
56331 }
56332
56333
56334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
56335   int jresult ;
56336   int result;
56337
56338   {
56339     try {
56340       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
56341     } catch (std::out_of_range& e) {
56342       {
56343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56344       };
56345     } catch (std::exception& e) {
56346       {
56347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56348       };
56349     } catch (...) {
56350       {
56351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56352       };
56353     }
56354   }
56355   jresult = (int)result;
56356   return jresult;
56357 }
56358
56359
56360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
56361   int jresult ;
56362   int result;
56363
56364   {
56365     try {
56366       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
56367     } catch (std::out_of_range& e) {
56368       {
56369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56370       };
56371     } catch (std::exception& e) {
56372       {
56373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56374       };
56375     } catch (...) {
56376       {
56377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56378       };
56379     }
56380   }
56381   jresult = (int)result;
56382   return jresult;
56383 }
56384
56385
56386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
56387   int jresult ;
56388   int result;
56389
56390   {
56391     try {
56392       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
56393     } catch (std::out_of_range& e) {
56394       {
56395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56396       };
56397     } catch (std::exception& e) {
56398       {
56399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56400       };
56401     } catch (...) {
56402       {
56403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56404       };
56405     }
56406   }
56407   jresult = (int)result;
56408   return jresult;
56409 }
56410
56411
56412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
56413   int jresult ;
56414   int result;
56415
56416   {
56417     try {
56418       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
56419     } catch (std::out_of_range& e) {
56420       {
56421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56422       };
56423     } catch (std::exception& e) {
56424       {
56425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56426       };
56427     } catch (...) {
56428       {
56429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56430       };
56431     }
56432   }
56433   jresult = (int)result;
56434   return jresult;
56435 }
56436
56437
56438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
56439   int jresult ;
56440   int result;
56441
56442   {
56443     try {
56444       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
56445     } catch (std::out_of_range& e) {
56446       {
56447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56448       };
56449     } catch (std::exception& e) {
56450       {
56451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56452       };
56453     } catch (...) {
56454       {
56455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56456       };
56457     }
56458   }
56459   jresult = (int)result;
56460   return jresult;
56461 }
56462
56463
56464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
56465   int jresult ;
56466   int result;
56467
56468   {
56469     try {
56470       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
56471     } catch (std::out_of_range& e) {
56472       {
56473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56474       };
56475     } catch (std::exception& e) {
56476       {
56477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56478       };
56479     } catch (...) {
56480       {
56481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56482       };
56483     }
56484   }
56485   jresult = (int)result;
56486   return jresult;
56487 }
56488
56489
56490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
56491   int jresult ;
56492   int result;
56493
56494   {
56495     try {
56496       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
56497     } catch (std::out_of_range& e) {
56498       {
56499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56500       };
56501     } catch (std::exception& e) {
56502       {
56503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56504       };
56505     } catch (...) {
56506       {
56507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56508       };
56509     }
56510   }
56511   jresult = (int)result;
56512   return jresult;
56513 }
56514
56515
56516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
56517   int jresult ;
56518   int result;
56519
56520   {
56521     try {
56522       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
56523     } catch (std::out_of_range& e) {
56524       {
56525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56526       };
56527     } catch (std::exception& e) {
56528       {
56529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56530       };
56531     } catch (...) {
56532       {
56533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56534       };
56535     }
56536   }
56537   jresult = (int)result;
56538   return jresult;
56539 }
56540
56541
56542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
56543   int jresult ;
56544   int result;
56545
56546   {
56547     try {
56548       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
56549     } catch (std::out_of_range& e) {
56550       {
56551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56552       };
56553     } catch (std::exception& e) {
56554       {
56555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56556       };
56557     } catch (...) {
56558       {
56559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56560       };
56561     }
56562   }
56563   jresult = (int)result;
56564   return jresult;
56565 }
56566
56567
56568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
56569   int jresult ;
56570   int result;
56571
56572   {
56573     try {
56574       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
56575     } catch (std::out_of_range& e) {
56576       {
56577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56578       };
56579     } catch (std::exception& e) {
56580       {
56581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56582       };
56583     } catch (...) {
56584       {
56585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56586       };
56587     }
56588   }
56589   jresult = (int)result;
56590   return jresult;
56591 }
56592
56593
56594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
56595   int jresult ;
56596   int result;
56597
56598   {
56599     try {
56600       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
56601     } catch (std::out_of_range& e) {
56602       {
56603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56604       };
56605     } catch (std::exception& e) {
56606       {
56607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56608       };
56609     } catch (...) {
56610       {
56611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56612       };
56613     }
56614   }
56615   jresult = (int)result;
56616   return jresult;
56617 }
56618
56619
56620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
56621   int jresult ;
56622   int result;
56623
56624   {
56625     try {
56626       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
56627     } catch (std::out_of_range& e) {
56628       {
56629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56630       };
56631     } catch (std::exception& e) {
56632       {
56633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56634       };
56635     } catch (...) {
56636       {
56637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56638       };
56639     }
56640   }
56641   jresult = (int)result;
56642   return jresult;
56643 }
56644
56645
56646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
56647   int jresult ;
56648   int result;
56649
56650   {
56651     try {
56652       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
56653     } catch (std::out_of_range& e) {
56654       {
56655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56656       };
56657     } catch (std::exception& e) {
56658       {
56659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56660       };
56661     } catch (...) {
56662       {
56663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56664       };
56665     }
56666   }
56667   jresult = (int)result;
56668   return jresult;
56669 }
56670
56671
56672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
56673   int jresult ;
56674   int result;
56675
56676   {
56677     try {
56678       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
56679     } catch (std::out_of_range& e) {
56680       {
56681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56682       };
56683     } catch (std::exception& e) {
56684       {
56685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56686       };
56687     } catch (...) {
56688       {
56689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56690       };
56691     }
56692   }
56693   jresult = (int)result;
56694   return jresult;
56695 }
56696
56697
56698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
56699   int jresult ;
56700   int result;
56701
56702   {
56703     try {
56704       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
56705     } catch (std::out_of_range& e) {
56706       {
56707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56708       };
56709     } catch (std::exception& e) {
56710       {
56711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56712       };
56713     } catch (...) {
56714       {
56715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56716       };
56717     }
56718   }
56719   jresult = (int)result;
56720   return jresult;
56721 }
56722
56723
56724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
56725   int jresult ;
56726   int result;
56727
56728   {
56729     try {
56730       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
56731     } catch (std::out_of_range& e) {
56732       {
56733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56734       };
56735     } catch (std::exception& e) {
56736       {
56737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56738       };
56739     } catch (...) {
56740       {
56741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56742       };
56743     }
56744   }
56745   jresult = (int)result;
56746   return jresult;
56747 }
56748
56749
56750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
56751   int jresult ;
56752   int result;
56753
56754   {
56755     try {
56756       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
56757     } catch (std::out_of_range& e) {
56758       {
56759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56760       };
56761     } catch (std::exception& e) {
56762       {
56763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56764       };
56765     } catch (...) {
56766       {
56767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56768       };
56769     }
56770   }
56771   jresult = (int)result;
56772   return jresult;
56773 }
56774
56775
56776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
56777   int jresult ;
56778   int result;
56779
56780   {
56781     try {
56782       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
56783     } catch (std::out_of_range& e) {
56784       {
56785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56786       };
56787     } catch (std::exception& e) {
56788       {
56789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56790       };
56791     } catch (...) {
56792       {
56793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56794       };
56795     }
56796   }
56797   jresult = (int)result;
56798   return jresult;
56799 }
56800
56801
56802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
56803   int jresult ;
56804   int result;
56805
56806   {
56807     try {
56808       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
56809     } catch (std::out_of_range& e) {
56810       {
56811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56812       };
56813     } catch (std::exception& e) {
56814       {
56815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56816       };
56817     } catch (...) {
56818       {
56819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56820       };
56821     }
56822   }
56823   jresult = (int)result;
56824   return jresult;
56825 }
56826
56827
56828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
56829   int jresult ;
56830   int result;
56831
56832   {
56833     try {
56834       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
56835     } catch (std::out_of_range& e) {
56836       {
56837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56838       };
56839     } catch (std::exception& e) {
56840       {
56841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56842       };
56843     } catch (...) {
56844       {
56845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56846       };
56847     }
56848   }
56849   jresult = (int)result;
56850   return jresult;
56851 }
56852
56853
56854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
56855   int jresult ;
56856   int result;
56857
56858   {
56859     try {
56860       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
56861     } catch (std::out_of_range& e) {
56862       {
56863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56864       };
56865     } catch (std::exception& e) {
56866       {
56867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56868       };
56869     } catch (...) {
56870       {
56871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56872       };
56873     }
56874   }
56875   jresult = (int)result;
56876   return jresult;
56877 }
56878
56879
56880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
56881   int jresult ;
56882   int result;
56883
56884   {
56885     try {
56886       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
56887     } catch (std::out_of_range& e) {
56888       {
56889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56890       };
56891     } catch (std::exception& e) {
56892       {
56893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56894       };
56895     } catch (...) {
56896       {
56897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56898       };
56899     }
56900   }
56901   jresult = (int)result;
56902   return jresult;
56903 }
56904
56905
56906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
56907   int jresult ;
56908   int result;
56909
56910   {
56911     try {
56912       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
56913     } catch (std::out_of_range& e) {
56914       {
56915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56916       };
56917     } catch (std::exception& e) {
56918       {
56919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56920       };
56921     } catch (...) {
56922       {
56923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56924       };
56925     }
56926   }
56927   jresult = (int)result;
56928   return jresult;
56929 }
56930
56931
56932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
56933   int jresult ;
56934   int result;
56935
56936   {
56937     try {
56938       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
56939     } catch (std::out_of_range& e) {
56940       {
56941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56942       };
56943     } catch (std::exception& e) {
56944       {
56945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56946       };
56947     } catch (...) {
56948       {
56949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56950       };
56951     }
56952   }
56953   jresult = (int)result;
56954   return jresult;
56955 }
56956
56957
56958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
56959   int jresult ;
56960   int result;
56961
56962   {
56963     try {
56964       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
56965     } catch (std::out_of_range& e) {
56966       {
56967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56968       };
56969     } catch (std::exception& e) {
56970       {
56971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56972       };
56973     } catch (...) {
56974       {
56975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56976       };
56977     }
56978   }
56979   jresult = (int)result;
56980   return jresult;
56981 }
56982
56983
56984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
56985   int jresult ;
56986   int result;
56987
56988   {
56989     try {
56990       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
56991     } catch (std::out_of_range& e) {
56992       {
56993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56994       };
56995     } catch (std::exception& e) {
56996       {
56997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56998       };
56999     } catch (...) {
57000       {
57001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57002       };
57003     }
57004   }
57005   jresult = (int)result;
57006   return jresult;
57007 }
57008
57009
57010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
57011   int jresult ;
57012   int result;
57013
57014   {
57015     try {
57016       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
57017     } catch (std::out_of_range& e) {
57018       {
57019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57020       };
57021     } catch (std::exception& e) {
57022       {
57023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57024       };
57025     } catch (...) {
57026       {
57027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57028       };
57029     }
57030   }
57031   jresult = (int)result;
57032   return jresult;
57033 }
57034
57035
57036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
57037   int jresult ;
57038   int result;
57039
57040   {
57041     try {
57042       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
57043     } catch (std::out_of_range& e) {
57044       {
57045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57046       };
57047     } catch (std::exception& e) {
57048       {
57049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57050       };
57051     } catch (...) {
57052       {
57053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57054       };
57055     }
57056   }
57057   jresult = (int)result;
57058   return jresult;
57059 }
57060
57061
57062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
57063   int jresult ;
57064   int result;
57065
57066   {
57067     try {
57068       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
57069     } catch (std::out_of_range& e) {
57070       {
57071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57072       };
57073     } catch (std::exception& e) {
57074       {
57075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57076       };
57077     } catch (...) {
57078       {
57079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57080       };
57081     }
57082   }
57083   jresult = (int)result;
57084   return jresult;
57085 }
57086
57087
57088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
57089   int jresult ;
57090   int result;
57091
57092   {
57093     try {
57094       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
57095     } catch (std::out_of_range& e) {
57096       {
57097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57098       };
57099     } catch (std::exception& e) {
57100       {
57101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57102       };
57103     } catch (...) {
57104       {
57105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57106       };
57107     }
57108   }
57109   jresult = (int)result;
57110   return jresult;
57111 }
57112
57113
57114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
57115   int jresult ;
57116   int result;
57117
57118   {
57119     try {
57120       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
57121     } catch (std::out_of_range& e) {
57122       {
57123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57124       };
57125     } catch (std::exception& e) {
57126       {
57127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57128       };
57129     } catch (...) {
57130       {
57131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57132       };
57133     }
57134   }
57135   jresult = (int)result;
57136   return jresult;
57137 }
57138
57139
57140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
57141   int jresult ;
57142   int result;
57143
57144   {
57145     try {
57146       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
57147     } catch (std::out_of_range& e) {
57148       {
57149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57150       };
57151     } catch (std::exception& e) {
57152       {
57153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57154       };
57155     } catch (...) {
57156       {
57157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57158       };
57159     }
57160   }
57161   jresult = (int)result;
57162   return jresult;
57163 }
57164
57165
57166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
57167   int jresult ;
57168   int result;
57169
57170   {
57171     try {
57172       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
57173     } catch (std::out_of_range& e) {
57174       {
57175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57176       };
57177     } catch (std::exception& e) {
57178       {
57179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57180       };
57181     } catch (...) {
57182       {
57183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57184       };
57185     }
57186   }
57187   jresult = (int)result;
57188   return jresult;
57189 }
57190
57191
57192 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
57193   int jresult ;
57194   int result;
57195
57196   {
57197     try {
57198       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
57199     } catch (std::out_of_range& e) {
57200       {
57201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57202       };
57203     } catch (std::exception& e) {
57204       {
57205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57206       };
57207     } catch (...) {
57208       {
57209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57210       };
57211     }
57212   }
57213   jresult = (int)result;
57214   return jresult;
57215 }
57216
57217
57218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
57219   int jresult ;
57220   int result;
57221
57222   {
57223     try {
57224       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
57225     } catch (std::out_of_range& e) {
57226       {
57227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57228       };
57229     } catch (std::exception& e) {
57230       {
57231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57232       };
57233     } catch (...) {
57234       {
57235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57236       };
57237     }
57238   }
57239   jresult = (int)result;
57240   return jresult;
57241 }
57242
57243
57244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
57245   int jresult ;
57246   int result;
57247
57248   {
57249     try {
57250       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
57251     } catch (std::out_of_range& e) {
57252       {
57253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57254       };
57255     } catch (std::exception& e) {
57256       {
57257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57258       };
57259     } catch (...) {
57260       {
57261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57262       };
57263     }
57264   }
57265   jresult = (int)result;
57266   return jresult;
57267 }
57268
57269
57270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
57271   void * jresult ;
57272   Dali::Toolkit::Builder *result = 0 ;
57273
57274   {
57275     try {
57276       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
57277     } catch (std::out_of_range& e) {
57278       {
57279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57280       };
57281     } catch (std::exception& e) {
57282       {
57283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57284       };
57285     } catch (...) {
57286       {
57287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57288       };
57289     }
57290   }
57291   jresult = (void *)result;
57292   return jresult;
57293 }
57294
57295
57296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
57297   void * jresult ;
57298   Dali::Toolkit::Builder result;
57299
57300   {
57301     try {
57302       result = Dali::Toolkit::Builder::New();
57303     } catch (std::out_of_range& e) {
57304       {
57305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57306       };
57307     } catch (std::exception& e) {
57308       {
57309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57310       };
57311     } catch (...) {
57312       {
57313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57314       };
57315     }
57316   }
57317   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
57318   return jresult;
57319 }
57320
57321
57322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
57323   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57324
57325   arg1 = (Dali::Toolkit::Builder *)jarg1;
57326   {
57327     try {
57328       delete arg1;
57329     } catch (std::out_of_range& e) {
57330       {
57331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57332       };
57333     } catch (std::exception& e) {
57334       {
57335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57336       };
57337     } catch (...) {
57338       {
57339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57340       };
57341     }
57342   }
57343 }
57344
57345
57346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
57347   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57348   std::string *arg2 = 0 ;
57349   Dali::Toolkit::Builder::UIFormat arg3 ;
57350
57351   arg1 = (Dali::Toolkit::Builder *)jarg1;
57352   if (!jarg2) {
57353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57354     return ;
57355   }
57356   std::string arg2_str(jarg2);
57357   arg2 = &arg2_str;
57358   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
57359   {
57360     try {
57361       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
57362     } catch (std::out_of_range& e) {
57363       {
57364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57365       };
57366     } catch (std::exception& e) {
57367       {
57368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57369       };
57370     } catch (...) {
57371       {
57372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57373       };
57374     }
57375   }
57376
57377   //argout typemap for const std::string&
57378
57379 }
57380
57381
57382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
57383   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57384   std::string *arg2 = 0 ;
57385
57386   arg1 = (Dali::Toolkit::Builder *)jarg1;
57387   if (!jarg2) {
57388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57389     return ;
57390   }
57391   std::string arg2_str(jarg2);
57392   arg2 = &arg2_str;
57393   {
57394     try {
57395       (arg1)->LoadFromString((std::string const &)*arg2);
57396     } catch (std::out_of_range& e) {
57397       {
57398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57399       };
57400     } catch (std::exception& e) {
57401       {
57402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57403       };
57404     } catch (...) {
57405       {
57406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57407       };
57408     }
57409   }
57410
57411   //argout typemap for const std::string&
57412
57413 }
57414
57415
57416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
57417   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57418   Dali::Property::Map *arg2 = 0 ;
57419
57420   arg1 = (Dali::Toolkit::Builder *)jarg1;
57421   arg2 = (Dali::Property::Map *)jarg2;
57422   if (!arg2) {
57423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57424     return ;
57425   }
57426   {
57427     try {
57428       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
57429     } catch (std::out_of_range& e) {
57430       {
57431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57432       };
57433     } catch (std::exception& e) {
57434       {
57435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57436       };
57437     } catch (...) {
57438       {
57439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57440       };
57441     }
57442   }
57443 }
57444
57445
57446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
57447   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57448   std::string *arg2 = 0 ;
57449   Dali::Property::Value *arg3 = 0 ;
57450
57451   arg1 = (Dali::Toolkit::Builder *)jarg1;
57452   if (!jarg2) {
57453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57454     return ;
57455   }
57456   std::string arg2_str(jarg2);
57457   arg2 = &arg2_str;
57458   arg3 = (Dali::Property::Value *)jarg3;
57459   if (!arg3) {
57460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
57461     return ;
57462   }
57463   {
57464     try {
57465       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
57466     } catch (std::out_of_range& e) {
57467       {
57468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57469       };
57470     } catch (std::exception& e) {
57471       {
57472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57473       };
57474     } catch (...) {
57475       {
57476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57477       };
57478     }
57479   }
57480
57481   //argout typemap for const std::string&
57482
57483 }
57484
57485
57486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
57487   void * jresult ;
57488   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57489   Dali::Property::Map *result = 0 ;
57490
57491   arg1 = (Dali::Toolkit::Builder *)jarg1;
57492   {
57493     try {
57494       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
57495     } catch (std::out_of_range& e) {
57496       {
57497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57498       };
57499     } catch (std::exception& e) {
57500       {
57501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57502       };
57503     } catch (...) {
57504       {
57505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57506       };
57507     }
57508   }
57509   jresult = (void *)result;
57510   return jresult;
57511 }
57512
57513
57514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
57515   void * jresult ;
57516   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57517   std::string *arg2 = 0 ;
57518   Dali::Property::Value *result = 0 ;
57519
57520   arg1 = (Dali::Toolkit::Builder *)jarg1;
57521   if (!jarg2) {
57522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57523     return 0;
57524   }
57525   std::string arg2_str(jarg2);
57526   arg2 = &arg2_str;
57527   {
57528     try {
57529       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
57530     } catch (std::out_of_range& e) {
57531       {
57532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57533       };
57534     } catch (std::exception& e) {
57535       {
57536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57537       };
57538     } catch (...) {
57539       {
57540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57541       };
57542     }
57543   }
57544   jresult = (void *)result;
57545
57546   //argout typemap for const std::string&
57547
57548   return jresult;
57549 }
57550
57551
57552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
57553   void * jresult ;
57554   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57555   std::string *arg2 = 0 ;
57556   Dali::Animation result;
57557
57558   arg1 = (Dali::Toolkit::Builder *)jarg1;
57559   if (!jarg2) {
57560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57561     return 0;
57562   }
57563   std::string arg2_str(jarg2);
57564   arg2 = &arg2_str;
57565   {
57566     try {
57567       result = (arg1)->CreateAnimation((std::string const &)*arg2);
57568     } catch (std::out_of_range& e) {
57569       {
57570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57571       };
57572     } catch (std::exception& e) {
57573       {
57574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57575       };
57576     } catch (...) {
57577       {
57578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57579       };
57580     }
57581   }
57582   jresult = new Dali::Animation((const Dali::Animation &)result);
57583
57584   //argout typemap for const std::string&
57585
57586   return jresult;
57587 }
57588
57589
57590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57591   void * jresult ;
57592   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57593   std::string *arg2 = 0 ;
57594   Dali::Property::Map *arg3 = 0 ;
57595   Dali::Animation result;
57596
57597   arg1 = (Dali::Toolkit::Builder *)jarg1;
57598   if (!jarg2) {
57599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57600     return 0;
57601   }
57602   std::string arg2_str(jarg2);
57603   arg2 = &arg2_str;
57604   arg3 = (Dali::Property::Map *)jarg3;
57605   if (!arg3) {
57606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57607     return 0;
57608   }
57609   {
57610     try {
57611       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57612     } catch (std::out_of_range& e) {
57613       {
57614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57615       };
57616     } catch (std::exception& e) {
57617       {
57618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57619       };
57620     } catch (...) {
57621       {
57622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57623       };
57624     }
57625   }
57626   jresult = new Dali::Animation((const Dali::Animation &)result);
57627
57628   //argout typemap for const std::string&
57629
57630   return jresult;
57631 }
57632
57633
57634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
57635   void * jresult ;
57636   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57637   std::string *arg2 = 0 ;
57638   Dali::Actor arg3 ;
57639   Dali::Actor *argp3 ;
57640   Dali::Animation result;
57641
57642   arg1 = (Dali::Toolkit::Builder *)jarg1;
57643   if (!jarg2) {
57644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57645     return 0;
57646   }
57647   std::string arg2_str(jarg2);
57648   arg2 = &arg2_str;
57649   argp3 = (Dali::Actor *)jarg3;
57650   if (!argp3) {
57651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57652     return 0;
57653   }
57654   arg3 = *argp3;
57655   {
57656     try {
57657       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
57658     } catch (std::out_of_range& e) {
57659       {
57660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57661       };
57662     } catch (std::exception& e) {
57663       {
57664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57665       };
57666     } catch (...) {
57667       {
57668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57669       };
57670     }
57671   }
57672   jresult = new Dali::Animation((const Dali::Animation &)result);
57673
57674   //argout typemap for const std::string&
57675
57676   return jresult;
57677 }
57678
57679
57680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
57681   void * jresult ;
57682   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57683   std::string *arg2 = 0 ;
57684   Dali::Property::Map *arg3 = 0 ;
57685   Dali::Actor arg4 ;
57686   Dali::Actor *argp4 ;
57687   Dali::Animation result;
57688
57689   arg1 = (Dali::Toolkit::Builder *)jarg1;
57690   if (!jarg2) {
57691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57692     return 0;
57693   }
57694   std::string arg2_str(jarg2);
57695   arg2 = &arg2_str;
57696   arg3 = (Dali::Property::Map *)jarg3;
57697   if (!arg3) {
57698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57699     return 0;
57700   }
57701   argp4 = (Dali::Actor *)jarg4;
57702   if (!argp4) {
57703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57704     return 0;
57705   }
57706   arg4 = *argp4;
57707   {
57708     try {
57709       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
57710     } catch (std::out_of_range& e) {
57711       {
57712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57713       };
57714     } catch (std::exception& e) {
57715       {
57716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57717       };
57718     } catch (...) {
57719       {
57720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57721       };
57722     }
57723   }
57724   jresult = new Dali::Animation((const Dali::Animation &)result);
57725
57726   //argout typemap for const std::string&
57727
57728   return jresult;
57729 }
57730
57731
57732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
57733   void * jresult ;
57734   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57735   std::string *arg2 = 0 ;
57736   Dali::BaseHandle result;
57737
57738   arg1 = (Dali::Toolkit::Builder *)jarg1;
57739   if (!jarg2) {
57740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57741     return 0;
57742   }
57743   std::string arg2_str(jarg2);
57744   arg2 = &arg2_str;
57745   {
57746     try {
57747       result = (arg1)->Create((std::string const &)*arg2);
57748     } catch (std::out_of_range& e) {
57749       {
57750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57751       };
57752     } catch (std::exception& e) {
57753       {
57754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57755       };
57756     } catch (...) {
57757       {
57758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57759       };
57760     }
57761   }
57762   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57763
57764   //argout typemap for const std::string&
57765
57766   return jresult;
57767 }
57768
57769
57770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57771   void * jresult ;
57772   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57773   std::string *arg2 = 0 ;
57774   Dali::Property::Map *arg3 = 0 ;
57775   Dali::BaseHandle result;
57776
57777   arg1 = (Dali::Toolkit::Builder *)jarg1;
57778   if (!jarg2) {
57779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57780     return 0;
57781   }
57782   std::string arg2_str(jarg2);
57783   arg2 = &arg2_str;
57784   arg3 = (Dali::Property::Map *)jarg3;
57785   if (!arg3) {
57786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57787     return 0;
57788   }
57789   {
57790     try {
57791       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57792     } catch (std::out_of_range& e) {
57793       {
57794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57795       };
57796     } catch (std::exception& e) {
57797       {
57798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57799       };
57800     } catch (...) {
57801       {
57802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57803       };
57804     }
57805   }
57806   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57807
57808   //argout typemap for const std::string&
57809
57810   return jresult;
57811 }
57812
57813
57814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
57815   void * jresult ;
57816   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57817   std::string *arg2 = 0 ;
57818   Dali::BaseHandle result;
57819
57820   arg1 = (Dali::Toolkit::Builder *)jarg1;
57821   if (!jarg2) {
57822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57823     return 0;
57824   }
57825   std::string arg2_str(jarg2);
57826   arg2 = &arg2_str;
57827   {
57828     try {
57829       result = (arg1)->CreateFromJson((std::string const &)*arg2);
57830     } catch (std::out_of_range& e) {
57831       {
57832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57833       };
57834     } catch (std::exception& e) {
57835       {
57836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57837       };
57838     } catch (...) {
57839       {
57840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57841       };
57842     }
57843   }
57844   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57845
57846   //argout typemap for const std::string&
57847
57848   return jresult;
57849 }
57850
57851
57852 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
57853   unsigned int jresult ;
57854   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57855   std::string *arg2 = 0 ;
57856   Dali::Handle *arg3 = 0 ;
57857   bool result;
57858
57859   arg1 = (Dali::Toolkit::Builder *)jarg1;
57860   if (!jarg2) {
57861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57862     return 0;
57863   }
57864   std::string arg2_str(jarg2);
57865   arg2 = &arg2_str;
57866   arg3 = (Dali::Handle *)jarg3;
57867   if (!arg3) {
57868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
57869     return 0;
57870   }
57871   {
57872     try {
57873       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
57874     } catch (std::out_of_range& e) {
57875       {
57876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57877       };
57878     } catch (std::exception& e) {
57879       {
57880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57881       };
57882     } catch (...) {
57883       {
57884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57885       };
57886     }
57887   }
57888   jresult = result;
57889
57890   //argout typemap for const std::string&
57891
57892   return jresult;
57893 }
57894
57895
57896 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
57897   unsigned int jresult ;
57898   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57899   Dali::Handle *arg2 = 0 ;
57900   std::string *arg3 = 0 ;
57901   bool result;
57902
57903   arg1 = (Dali::Toolkit::Builder *)jarg1;
57904   arg2 = (Dali::Handle *)jarg2;
57905   if (!arg2) {
57906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
57907     return 0;
57908   }
57909   if (!jarg3) {
57910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57911     return 0;
57912   }
57913   std::string arg3_str(jarg3);
57914   arg3 = &arg3_str;
57915   {
57916     try {
57917       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
57918     } catch (std::out_of_range& e) {
57919       {
57920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57921       };
57922     } catch (std::exception& e) {
57923       {
57924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57925       };
57926     } catch (...) {
57927       {
57928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57929       };
57930     }
57931   }
57932   jresult = result;
57933
57934   //argout typemap for const std::string&
57935
57936   return jresult;
57937 }
57938
57939
57940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
57941   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57942   Dali::Actor arg2 ;
57943   Dali::Actor *argp2 ;
57944
57945   arg1 = (Dali::Toolkit::Builder *)jarg1;
57946   argp2 = (Dali::Actor *)jarg2;
57947   if (!argp2) {
57948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57949     return ;
57950   }
57951   arg2 = *argp2;
57952   {
57953     try {
57954       (arg1)->AddActors(arg2);
57955     } catch (std::out_of_range& e) {
57956       {
57957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57958       };
57959     } catch (std::exception& e) {
57960       {
57961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57962       };
57963     } catch (...) {
57964       {
57965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57966       };
57967     }
57968   }
57969 }
57970
57971
57972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57973   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57974   std::string *arg2 = 0 ;
57975   Dali::Actor arg3 ;
57976   Dali::Actor *argp3 ;
57977
57978   arg1 = (Dali::Toolkit::Builder *)jarg1;
57979   if (!jarg2) {
57980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57981     return ;
57982   }
57983   std::string arg2_str(jarg2);
57984   arg2 = &arg2_str;
57985   argp3 = (Dali::Actor *)jarg3;
57986   if (!argp3) {
57987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57988     return ;
57989   }
57990   arg3 = *argp3;
57991   {
57992     try {
57993       (arg1)->AddActors((std::string const &)*arg2,arg3);
57994     } catch (std::out_of_range& e) {
57995       {
57996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57997       };
57998     } catch (std::exception& e) {
57999       {
58000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58001       };
58002     } catch (...) {
58003       {
58004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58005       };
58006     }
58007   }
58008
58009   //argout typemap for const std::string&
58010
58011 }
58012
58013
58014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
58015   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58016   std::string *arg2 = 0 ;
58017
58018   arg1 = (Dali::Toolkit::Builder *)jarg1;
58019   if (!jarg2) {
58020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58021     return ;
58022   }
58023   std::string arg2_str(jarg2);
58024   arg2 = &arg2_str;
58025   {
58026     try {
58027       (arg1)->CreateRenderTask((std::string const &)*arg2);
58028     } catch (std::out_of_range& e) {
58029       {
58030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58031       };
58032     } catch (std::exception& e) {
58033       {
58034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58035       };
58036     } catch (...) {
58037       {
58038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58039       };
58040     }
58041   }
58042
58043   //argout typemap for const std::string&
58044
58045 }
58046
58047
58048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
58049   void * jresult ;
58050   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58051   std::string *arg2 = 0 ;
58052   Dali::FrameBufferImage result;
58053
58054   arg1 = (Dali::Toolkit::Builder *)jarg1;
58055   if (!jarg2) {
58056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58057     return 0;
58058   }
58059   std::string arg2_str(jarg2);
58060   arg2 = &arg2_str;
58061   {
58062     try {
58063       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
58064     } catch (std::out_of_range& e) {
58065       {
58066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58067       };
58068     } catch (std::exception& e) {
58069       {
58070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58071       };
58072     } catch (...) {
58073       {
58074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58075       };
58076     }
58077   }
58078   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
58079
58080   //argout typemap for const std::string&
58081
58082   return jresult;
58083 }
58084
58085
58086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
58087   void * jresult ;
58088   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58089   std::string *arg2 = 0 ;
58090   Dali::Path result;
58091
58092   arg1 = (Dali::Toolkit::Builder *)jarg1;
58093   if (!jarg2) {
58094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58095     return 0;
58096   }
58097   std::string arg2_str(jarg2);
58098   arg2 = &arg2_str;
58099   {
58100     try {
58101       result = (arg1)->GetPath((std::string const &)*arg2);
58102     } catch (std::out_of_range& e) {
58103       {
58104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58105       };
58106     } catch (std::exception& e) {
58107       {
58108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58109       };
58110     } catch (...) {
58111       {
58112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58113       };
58114     }
58115   }
58116   jresult = new Dali::Path((const Dali::Path &)result);
58117
58118   //argout typemap for const std::string&
58119
58120   return jresult;
58121 }
58122
58123
58124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
58125   void * jresult ;
58126   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58127   std::string *arg2 = 0 ;
58128   Dali::PathConstrainer result;
58129
58130   arg1 = (Dali::Toolkit::Builder *)jarg1;
58131   if (!jarg2) {
58132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58133     return 0;
58134   }
58135   std::string arg2_str(jarg2);
58136   arg2 = &arg2_str;
58137   {
58138     try {
58139       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
58140     } catch (std::out_of_range& e) {
58141       {
58142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58143       };
58144     } catch (std::exception& e) {
58145       {
58146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58147       };
58148     } catch (...) {
58149       {
58150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58151       };
58152     }
58153   }
58154   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
58155
58156   //argout typemap for const std::string&
58157
58158   return jresult;
58159 }
58160
58161
58162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
58163   void * jresult ;
58164   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58165   std::string *arg2 = 0 ;
58166   Dali::LinearConstrainer result;
58167
58168   arg1 = (Dali::Toolkit::Builder *)jarg1;
58169   if (!jarg2) {
58170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58171     return 0;
58172   }
58173   std::string arg2_str(jarg2);
58174   arg2 = &arg2_str;
58175   {
58176     try {
58177       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
58178     } catch (std::out_of_range& e) {
58179       {
58180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58181       };
58182     } catch (std::exception& e) {
58183       {
58184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58185       };
58186     } catch (...) {
58187       {
58188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58189       };
58190     }
58191   }
58192   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
58193
58194   //argout typemap for const std::string&
58195
58196   return jresult;
58197 }
58198
58199
58200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
58201   void * jresult ;
58202   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58203   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
58204
58205   arg1 = (Dali::Toolkit::Builder *)jarg1;
58206   {
58207     try {
58208       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
58209     } catch (std::out_of_range& e) {
58210       {
58211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58212       };
58213     } catch (std::exception& e) {
58214       {
58215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58216       };
58217     } catch (...) {
58218       {
58219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58220       };
58221     }
58222   }
58223   jresult = (void *)result;
58224   return jresult;
58225 }
58226
58227
58228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
58229   void * jresult ;
58230   Dali::Toolkit::TransitionData *result = 0 ;
58231
58232   {
58233     try {
58234       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
58235     } catch (std::out_of_range& e) {
58236       {
58237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58238       };
58239     } catch (std::exception& e) {
58240       {
58241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58242       };
58243     } catch (...) {
58244       {
58245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58246       };
58247     }
58248   }
58249   jresult = (void *)result;
58250   return jresult;
58251 }
58252
58253
58254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
58255   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58256
58257   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58258   {
58259     try {
58260       delete arg1;
58261     } catch (std::out_of_range& e) {
58262       {
58263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58264       };
58265     } catch (std::exception& e) {
58266       {
58267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58268       };
58269     } catch (...) {
58270       {
58271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58272       };
58273     }
58274   }
58275 }
58276
58277
58278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
58279   void * jresult ;
58280   Dali::Property::Map *arg1 = 0 ;
58281   Dali::Toolkit::TransitionData result;
58282
58283   arg1 = (Dali::Property::Map *)jarg1;
58284   if (!arg1) {
58285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58286     return 0;
58287   }
58288   {
58289     try {
58290       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
58291     } catch (std::out_of_range& e) {
58292       {
58293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58294       };
58295     } catch (std::exception& e) {
58296       {
58297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58298       };
58299     } catch (...) {
58300       {
58301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58302       };
58303     }
58304   }
58305   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58306   return jresult;
58307 }
58308
58309
58310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
58311   void * jresult ;
58312   Dali::Property::Array *arg1 = 0 ;
58313   Dali::Toolkit::TransitionData result;
58314
58315   arg1 = (Dali::Property::Array *)jarg1;
58316   if (!arg1) {
58317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
58318     return 0;
58319   }
58320   {
58321     try {
58322       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
58323     } catch (std::out_of_range& e) {
58324       {
58325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58326       };
58327     } catch (std::exception& e) {
58328       {
58329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58330       };
58331     } catch (...) {
58332       {
58333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58334       };
58335     }
58336   }
58337   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58338   return jresult;
58339 }
58340
58341
58342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
58343   void * jresult ;
58344   Dali::BaseHandle arg1 ;
58345   Dali::BaseHandle *argp1 ;
58346   Dali::Toolkit::TransitionData result;
58347
58348   argp1 = (Dali::BaseHandle *)jarg1;
58349   if (!argp1) {
58350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58351     return 0;
58352   }
58353   arg1 = *argp1;
58354   {
58355     try {
58356       result = Dali::Toolkit::TransitionData::DownCast(arg1);
58357     } catch (std::out_of_range& e) {
58358       {
58359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58360       };
58361     } catch (std::exception& e) {
58362       {
58363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58364       };
58365     } catch (...) {
58366       {
58367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58368       };
58369     }
58370   }
58371   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58372   return jresult;
58373 }
58374
58375
58376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
58377   void * jresult ;
58378   Dali::Toolkit::TransitionData *arg1 = 0 ;
58379   Dali::Toolkit::TransitionData *result = 0 ;
58380
58381   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58382   if (!arg1) {
58383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58384     return 0;
58385   }
58386   {
58387     try {
58388       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
58389     } catch (std::out_of_range& e) {
58390       {
58391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58392       };
58393     } catch (std::exception& e) {
58394       {
58395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58396       };
58397     } catch (...) {
58398       {
58399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58400       };
58401     }
58402   }
58403   jresult = (void *)result;
58404   return jresult;
58405 }
58406
58407
58408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
58409   void * jresult ;
58410   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58411   Dali::Toolkit::TransitionData *arg2 = 0 ;
58412   Dali::Toolkit::TransitionData *result = 0 ;
58413
58414   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58415   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
58416   if (!arg2) {
58417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58418     return 0;
58419   }
58420   {
58421     try {
58422       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
58423     } catch (std::out_of_range& e) {
58424       {
58425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58426       };
58427     } catch (std::exception& e) {
58428       {
58429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58430       };
58431     } catch (...) {
58432       {
58433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58434       };
58435     }
58436   }
58437   jresult = (void *)result;
58438   return jresult;
58439 }
58440
58441
58442 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
58443   unsigned long jresult ;
58444   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58445   size_t result;
58446
58447   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58448   {
58449     try {
58450       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
58451     } catch (std::out_of_range& e) {
58452       {
58453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58454       };
58455     } catch (std::exception& e) {
58456       {
58457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58458       };
58459     } catch (...) {
58460       {
58461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58462       };
58463     }
58464   }
58465   jresult = (unsigned long)result;
58466   return jresult;
58467 }
58468
58469
58470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
58471   void * jresult ;
58472   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58473   size_t arg2 ;
58474   Dali::Property::Map result;
58475
58476   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58477   arg2 = (size_t)jarg2;
58478   {
58479     try {
58480       result = (arg1)->GetAnimatorAt(arg2);
58481     } catch (std::out_of_range& e) {
58482       {
58483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58484       };
58485     } catch (std::exception& e) {
58486       {
58487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58488       };
58489     } catch (...) {
58490       {
58491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58492       };
58493     }
58494   }
58495   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
58496   return jresult;
58497 }
58498
58499
58500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
58501   void * jresult ;
58502   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
58503   Dali::Toolkit::TransitionData *result = 0 ;
58504
58505   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
58506   {
58507     try {
58508       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
58509     } catch (std::out_of_range& e) {
58510       {
58511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58512       };
58513     } catch (std::exception& e) {
58514       {
58515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58516       };
58517     } catch (...) {
58518       {
58519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58520       };
58521     }
58522   }
58523   jresult = (void *)result;
58524   return jresult;
58525 }
58526
58527
58528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
58529   int jresult ;
58530   int result;
58531
58532   {
58533     try {
58534       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
58535     } catch (std::out_of_range& e) {
58536       {
58537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58538       };
58539     } catch (std::exception& e) {
58540       {
58541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58542       };
58543     } catch (...) {
58544       {
58545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58546       };
58547     }
58548   }
58549   jresult = (int)result;
58550   return jresult;
58551 }
58552
58553
58554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
58555   int jresult ;
58556   int result;
58557
58558   {
58559     try {
58560       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
58561     } catch (std::out_of_range& e) {
58562       {
58563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58564       };
58565     } catch (std::exception& e) {
58566       {
58567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58568       };
58569     } catch (...) {
58570       {
58571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58572       };
58573     }
58574   }
58575   jresult = (int)result;
58576   return jresult;
58577 }
58578
58579
58580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
58581   int jresult ;
58582   int result;
58583
58584   {
58585     try {
58586       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
58587     } catch (std::out_of_range& e) {
58588       {
58589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58590       };
58591     } catch (std::exception& e) {
58592       {
58593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58594       };
58595     } catch (...) {
58596       {
58597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58598       };
58599     }
58600   }
58601   jresult = (int)result;
58602   return jresult;
58603 }
58604
58605
58606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
58607   int jresult ;
58608   int result;
58609
58610   {
58611     try {
58612       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
58613     } catch (std::out_of_range& e) {
58614       {
58615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58616       };
58617     } catch (std::exception& e) {
58618       {
58619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58620       };
58621     } catch (...) {
58622       {
58623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58624       };
58625     }
58626   }
58627   jresult = (int)result;
58628   return jresult;
58629 }
58630
58631
58632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
58633   int jresult ;
58634   int result;
58635
58636   {
58637     try {
58638       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
58639     } catch (std::out_of_range& e) {
58640       {
58641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58642       };
58643     } catch (std::exception& e) {
58644       {
58645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58646       };
58647     } catch (...) {
58648       {
58649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58650       };
58651     }
58652   }
58653   jresult = (int)result;
58654   return jresult;
58655 }
58656
58657
58658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
58659   int jresult ;
58660   int result;
58661
58662   {
58663     try {
58664       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
58665     } catch (std::out_of_range& e) {
58666       {
58667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58668       };
58669     } catch (std::exception& e) {
58670       {
58671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58672       };
58673     } catch (...) {
58674       {
58675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58676       };
58677     }
58678   }
58679   jresult = (int)result;
58680   return jresult;
58681 }
58682
58683
58684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
58685   int jresult ;
58686   int result;
58687
58688   {
58689     try {
58690       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
58691     } catch (std::out_of_range& e) {
58692       {
58693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58694       };
58695     } catch (std::exception& e) {
58696       {
58697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58698       };
58699     } catch (...) {
58700       {
58701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58702       };
58703     }
58704   }
58705   jresult = (int)result;
58706   return jresult;
58707 }
58708
58709
58710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
58711   int jresult ;
58712   int result;
58713
58714   {
58715     try {
58716       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
58717     } catch (std::out_of_range& e) {
58718       {
58719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58720       };
58721     } catch (std::exception& e) {
58722       {
58723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58724       };
58725     } catch (...) {
58726       {
58727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58728       };
58729     }
58730   }
58731   jresult = (int)result;
58732   return jresult;
58733 }
58734
58735
58736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
58737   int jresult ;
58738   int result;
58739
58740   {
58741     try {
58742       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
58743     } catch (std::out_of_range& e) {
58744       {
58745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58746       };
58747     } catch (std::exception& e) {
58748       {
58749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58750       };
58751     } catch (...) {
58752       {
58753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58754       };
58755     }
58756   }
58757   jresult = (int)result;
58758   return jresult;
58759 }
58760
58761
58762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
58763   int jresult ;
58764   int result;
58765
58766   {
58767     try {
58768       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
58769     } catch (std::out_of_range& e) {
58770       {
58771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58772       };
58773     } catch (std::exception& e) {
58774       {
58775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58776       };
58777     } catch (...) {
58778       {
58779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58780       };
58781     }
58782   }
58783   jresult = (int)result;
58784   return jresult;
58785 }
58786
58787
58788 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
58789   int jresult ;
58790   int result;
58791
58792   {
58793     try {
58794       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
58795     } catch (std::out_of_range& e) {
58796       {
58797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58798       };
58799     } catch (std::exception& e) {
58800       {
58801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58802       };
58803     } catch (...) {
58804       {
58805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58806       };
58807     }
58808   }
58809   jresult = (int)result;
58810   return jresult;
58811 }
58812
58813
58814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
58815   int jresult ;
58816   int result;
58817
58818   {
58819     try {
58820       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
58821     } catch (std::out_of_range& e) {
58822       {
58823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58824       };
58825     } catch (std::exception& e) {
58826       {
58827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58828       };
58829     } catch (...) {
58830       {
58831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58832       };
58833     }
58834   }
58835   jresult = (int)result;
58836   return jresult;
58837 }
58838
58839
58840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
58841   int jresult ;
58842   int result;
58843
58844   {
58845     try {
58846       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
58847     } catch (std::out_of_range& e) {
58848       {
58849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58850       };
58851     } catch (std::exception& e) {
58852       {
58853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58854       };
58855     } catch (...) {
58856       {
58857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58858       };
58859     }
58860   }
58861   jresult = (int)result;
58862   return jresult;
58863 }
58864
58865
58866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
58867   int jresult ;
58868   int result;
58869
58870   {
58871     try {
58872       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
58873     } catch (std::out_of_range& e) {
58874       {
58875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58876       };
58877     } catch (std::exception& e) {
58878       {
58879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58880       };
58881     } catch (...) {
58882       {
58883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58884       };
58885     }
58886   }
58887   jresult = (int)result;
58888   return jresult;
58889 }
58890
58891
58892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
58893   void * jresult ;
58894   Dali::Toolkit::Control result;
58895
58896   {
58897     try {
58898       result = Dali::Toolkit::Internal::Control::New();
58899     } catch (std::out_of_range& e) {
58900       {
58901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58902       };
58903     } catch (std::exception& e) {
58904       {
58905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58906       };
58907     } catch (...) {
58908       {
58909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58910       };
58911     }
58912   }
58913   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
58914   return jresult;
58915 }
58916
58917
58918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
58919   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58920   std::string *arg2 = 0 ;
58921
58922   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58923   if (!jarg2) {
58924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58925     return ;
58926   }
58927   std::string arg2_str(jarg2);
58928   arg2 = &arg2_str;
58929   {
58930     try {
58931       (arg1)->SetStyleName((std::string const &)*arg2);
58932     } catch (std::out_of_range& e) {
58933       {
58934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58935       };
58936     } catch (std::exception& e) {
58937       {
58938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58939       };
58940     } catch (...) {
58941       {
58942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58943       };
58944     }
58945   }
58946
58947   //argout typemap for const std::string&
58948
58949 }
58950
58951
58952 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
58953   char * jresult ;
58954   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58955   std::string *result = 0 ;
58956
58957   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58958   {
58959     try {
58960       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
58961     } catch (std::out_of_range& e) {
58962       {
58963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58964       };
58965     } catch (std::exception& e) {
58966       {
58967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58968       };
58969     } catch (...) {
58970       {
58971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58972       };
58973     }
58974   }
58975   jresult = SWIG_csharp_string_callback(result->c_str());
58976   return jresult;
58977 }
58978
58979
58980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
58981   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58982   Dali::Vector4 *arg2 = 0 ;
58983
58984   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58985   arg2 = (Dali::Vector4 *)jarg2;
58986   if (!arg2) {
58987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
58988     return ;
58989   }
58990   {
58991     try {
58992       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
58993     } catch (std::out_of_range& e) {
58994       {
58995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58996       };
58997     } catch (std::exception& e) {
58998       {
58999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59000       };
59001     } catch (...) {
59002       {
59003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59004       };
59005     }
59006   }
59007 }
59008
59009
59010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
59011   void * jresult ;
59012   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59013   Dali::Vector4 result;
59014
59015   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59016   {
59017     try {
59018       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
59019     } catch (std::out_of_range& e) {
59020       {
59021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59022       };
59023     } catch (std::exception& e) {
59024       {
59025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59026       };
59027     } catch (...) {
59028       {
59029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59030       };
59031     }
59032   }
59033   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
59034   return jresult;
59035 }
59036
59037
59038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
59039   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59040   Dali::Image arg2 ;
59041   Dali::Image *argp2 ;
59042
59043   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59044   argp2 = (Dali::Image *)jarg2;
59045   if (!argp2) {
59046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
59047     return ;
59048   }
59049   arg2 = *argp2;
59050   {
59051     try {
59052       (arg1)->SetBackgroundImage(arg2);
59053     } catch (std::out_of_range& e) {
59054       {
59055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59056       };
59057     } catch (std::exception& e) {
59058       {
59059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59060       };
59061     } catch (...) {
59062       {
59063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59064       };
59065     }
59066   }
59067 }
59068
59069
59070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
59071   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59072   Dali::Property::Map *arg2 = 0 ;
59073
59074   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59075   arg2 = (Dali::Property::Map *)jarg2;
59076   if (!arg2) {
59077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59078     return ;
59079   }
59080   {
59081     try {
59082       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
59083     } catch (std::out_of_range& e) {
59084       {
59085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59086       };
59087     } catch (std::exception& e) {
59088       {
59089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59090       };
59091     } catch (...) {
59092       {
59093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59094       };
59095     }
59096   }
59097 }
59098
59099
59100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
59101   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59102
59103   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59104   {
59105     try {
59106       (arg1)->ClearBackground();
59107     } catch (std::out_of_range& e) {
59108       {
59109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59110       };
59111     } catch (std::exception& e) {
59112       {
59113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59114       };
59115     } catch (...) {
59116       {
59117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59118       };
59119     }
59120   }
59121 }
59122
59123
59124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
59125   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59126   Dali::Gesture::Type arg2 ;
59127
59128   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59129   arg2 = (Dali::Gesture::Type)jarg2;
59130   {
59131     try {
59132       (arg1)->EnableGestureDetection(arg2);
59133     } catch (std::out_of_range& e) {
59134       {
59135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59136       };
59137     } catch (std::exception& e) {
59138       {
59139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59140       };
59141     } catch (...) {
59142       {
59143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59144       };
59145     }
59146   }
59147 }
59148
59149
59150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
59151   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59152   Dali::Gesture::Type arg2 ;
59153
59154   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59155   arg2 = (Dali::Gesture::Type)jarg2;
59156   {
59157     try {
59158       (arg1)->DisableGestureDetection(arg2);
59159     } catch (std::out_of_range& e) {
59160       {
59161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59162       };
59163     } catch (std::exception& e) {
59164       {
59165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59166       };
59167     } catch (...) {
59168       {
59169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59170       };
59171     }
59172   }
59173 }
59174
59175
59176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
59177   void * jresult ;
59178   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59179   Dali::PinchGestureDetector result;
59180
59181   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59182   {
59183     try {
59184       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
59185     } catch (std::out_of_range& e) {
59186       {
59187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59188       };
59189     } catch (std::exception& e) {
59190       {
59191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59192       };
59193     } catch (...) {
59194       {
59195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59196       };
59197     }
59198   }
59199   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
59200   return jresult;
59201 }
59202
59203
59204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
59205   void * jresult ;
59206   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59207   Dali::PanGestureDetector result;
59208
59209   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59210   {
59211     try {
59212       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
59213     } catch (std::out_of_range& e) {
59214       {
59215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59216       };
59217     } catch (std::exception& e) {
59218       {
59219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59220       };
59221     } catch (...) {
59222       {
59223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59224       };
59225     }
59226   }
59227   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
59228   return jresult;
59229 }
59230
59231
59232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
59233   void * jresult ;
59234   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59235   Dali::TapGestureDetector result;
59236
59237   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59238   {
59239     try {
59240       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
59241     } catch (std::out_of_range& e) {
59242       {
59243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59244       };
59245     } catch (std::exception& e) {
59246       {
59247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59248       };
59249     } catch (...) {
59250       {
59251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59252       };
59253     }
59254   }
59255   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
59256   return jresult;
59257 }
59258
59259
59260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
59261   void * jresult ;
59262   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59263   Dali::LongPressGestureDetector result;
59264
59265   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59266   {
59267     try {
59268       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
59269     } catch (std::out_of_range& e) {
59270       {
59271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59272       };
59273     } catch (std::exception& e) {
59274       {
59275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59276       };
59277     } catch (...) {
59278       {
59279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59280       };
59281     }
59282   }
59283   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
59284   return jresult;
59285 }
59286
59287
59288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
59289   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59290   bool arg2 ;
59291
59292   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59293   arg2 = jarg2 ? true : false;
59294   {
59295     try {
59296       (arg1)->SetKeyboardNavigationSupport(arg2);
59297     } catch (std::out_of_range& e) {
59298       {
59299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59300       };
59301     } catch (std::exception& e) {
59302       {
59303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59304       };
59305     } catch (...) {
59306       {
59307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59308       };
59309     }
59310   }
59311 }
59312
59313
59314 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
59315   unsigned int jresult ;
59316   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59317   bool result;
59318
59319   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59320   {
59321     try {
59322       result = (bool)(arg1)->IsKeyboardNavigationSupported();
59323     } catch (std::out_of_range& e) {
59324       {
59325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59326       };
59327     } catch (std::exception& e) {
59328       {
59329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59330       };
59331     } catch (...) {
59332       {
59333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59334       };
59335     }
59336   }
59337   jresult = result;
59338   return jresult;
59339 }
59340
59341
59342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
59343   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59344
59345   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59346   {
59347     try {
59348       (arg1)->SetKeyInputFocus();
59349     } catch (std::out_of_range& e) {
59350       {
59351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59352       };
59353     } catch (std::exception& e) {
59354       {
59355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59356       };
59357     } catch (...) {
59358       {
59359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59360       };
59361     }
59362   }
59363 }
59364
59365
59366 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
59367   unsigned int jresult ;
59368   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59369   bool result;
59370
59371   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59372   {
59373     try {
59374       result = (bool)(arg1)->HasKeyInputFocus();
59375     } catch (std::out_of_range& e) {
59376       {
59377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59378       };
59379     } catch (std::exception& e) {
59380       {
59381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59382       };
59383     } catch (...) {
59384       {
59385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59386       };
59387     }
59388   }
59389   jresult = result;
59390   return jresult;
59391 }
59392
59393
59394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
59395   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59396
59397   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59398   {
59399     try {
59400       (arg1)->ClearKeyInputFocus();
59401     } catch (std::out_of_range& e) {
59402       {
59403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59404       };
59405     } catch (std::exception& e) {
59406       {
59407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59408       };
59409     } catch (...) {
59410       {
59411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59412       };
59413     }
59414   }
59415 }
59416
59417
59418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
59419   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59420   bool arg2 ;
59421
59422   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59423   arg2 = jarg2 ? true : false;
59424   {
59425     try {
59426       (arg1)->SetAsKeyboardFocusGroup(arg2);
59427     } catch (std::out_of_range& e) {
59428       {
59429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59430       };
59431     } catch (std::exception& e) {
59432       {
59433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59434       };
59435     } catch (...) {
59436       {
59437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59438       };
59439     }
59440   }
59441 }
59442
59443
59444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
59445   unsigned int jresult ;
59446   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59447   bool result;
59448
59449   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59450   {
59451     try {
59452       result = (bool)(arg1)->IsKeyboardFocusGroup();
59453     } catch (std::out_of_range& e) {
59454       {
59455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59456       };
59457     } catch (std::exception& e) {
59458       {
59459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59460       };
59461     } catch (...) {
59462       {
59463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59464       };
59465     }
59466   }
59467   jresult = result;
59468   return jresult;
59469 }
59470
59471
59472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(void * jarg1) {
59473   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59474
59475   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59476   {
59477     try {
59478       (arg1)->AccessibilityActivate();
59479     } catch (std::out_of_range& e) {
59480       {
59481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59482       };
59483     } catch (std::exception& e) {
59484       {
59485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59486       };
59487     } catch (...) {
59488       {
59489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59490       };
59491     }
59492   }
59493 }
59494
59495
59496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
59497   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59498
59499   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59500   {
59501     try {
59502       (arg1)->KeyboardEnter();
59503     } catch (std::out_of_range& e) {
59504       {
59505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59506       };
59507     } catch (std::exception& e) {
59508       {
59509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59510       };
59511     } catch (...) {
59512       {
59513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59514       };
59515     }
59516   }
59517 }
59518
59519
59520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
59521   void * jresult ;
59522   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59523   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
59524
59525   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59526   {
59527     try {
59528       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
59529     } catch (std::out_of_range& e) {
59530       {
59531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59532       };
59533     } catch (std::exception& e) {
59534       {
59535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59536       };
59537     } catch (...) {
59538       {
59539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59540       };
59541     }
59542   }
59543   jresult = (void *)result;
59544   return jresult;
59545 }
59546
59547
59548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
59549   void * jresult ;
59550   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59551   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59552
59553   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59554   {
59555     try {
59556       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
59557     } catch (std::out_of_range& e) {
59558       {
59559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59560       };
59561     } catch (std::exception& e) {
59562       {
59563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59564       };
59565     } catch (...) {
59566       {
59567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59568       };
59569     }
59570   }
59571   jresult = (void *)result;
59572   return jresult;
59573 }
59574
59575
59576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
59577   void * jresult ;
59578   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59579   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59580
59581   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59582   {
59583     try {
59584       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
59585     } catch (std::out_of_range& e) {
59586       {
59587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59588       };
59589     } catch (std::exception& e) {
59590       {
59591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59592       };
59593     } catch (...) {
59594       {
59595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59596       };
59597     }
59598   }
59599   jresult = (void *)result;
59600   return jresult;
59601 }
59602
59603
59604 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
59605   unsigned int jresult ;
59606   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59607   Dali::KeyEvent *arg2 = 0 ;
59608   bool result;
59609
59610   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59611   arg2 = (Dali::KeyEvent *)jarg2;
59612   if (!arg2) {
59613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
59614     return 0;
59615   }
59616   {
59617     try {
59618       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
59619     } catch (std::out_of_range& e) {
59620       {
59621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59622       };
59623     } catch (std::exception& e) {
59624       {
59625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59626       };
59627     } catch (...) {
59628       {
59629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59630       };
59631     }
59632   }
59633   jresult = result;
59634   return jresult;
59635 }
59636
59637
59638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
59639   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59640   int arg2 ;
59641   SwigDirector_ViewImpl *darg = 0;
59642
59643   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59644   arg2 = (int)jarg2;
59645   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59646   {
59647     try {
59648       (darg)->OnStageConnection(arg2);
59649     } catch (std::out_of_range& e) {
59650       {
59651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59652       };
59653     } catch (std::exception& e) {
59654       {
59655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59656       };
59657     } catch (...) {
59658       {
59659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59660       };
59661     }
59662   }
59663 }
59664
59665
59666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
59667   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59668   int arg2 ;
59669   SwigDirector_ViewImpl *darg = 0;
59670
59671   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59672   arg2 = (int)jarg2;
59673   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59674   {
59675     try {
59676       (darg)->OnStageConnectionSwigPublic(arg2);
59677     } catch (std::out_of_range& e) {
59678       {
59679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59680       };
59681     } catch (std::exception& e) {
59682       {
59683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59684       };
59685     } catch (...) {
59686       {
59687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59688       };
59689     }
59690   }
59691 }
59692
59693
59694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
59695   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59696   SwigDirector_ViewImpl *darg = 0;
59697
59698   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59699   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59700   {
59701     try {
59702       (darg)->OnStageDisconnection();
59703     } catch (std::out_of_range& e) {
59704       {
59705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59706       };
59707     } catch (std::exception& e) {
59708       {
59709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59710       };
59711     } catch (...) {
59712       {
59713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59714       };
59715     }
59716   }
59717 }
59718
59719
59720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
59721   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59722   SwigDirector_ViewImpl *darg = 0;
59723
59724   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59725   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59726   {
59727     try {
59728       (darg)->OnStageDisconnectionSwigPublic();
59729     } catch (std::out_of_range& e) {
59730       {
59731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59732       };
59733     } catch (std::exception& e) {
59734       {
59735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59736       };
59737     } catch (...) {
59738       {
59739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59740       };
59741     }
59742   }
59743 }
59744
59745
59746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
59747   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59748   Dali::Actor *arg2 = 0 ;
59749   SwigDirector_ViewImpl *darg = 0;
59750
59751   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59752   arg2 = (Dali::Actor *)jarg2;
59753   if (!arg2) {
59754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59755     return ;
59756   }
59757   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59758   {
59759     try {
59760       (darg)->OnChildAdd(*arg2);
59761     } catch (std::out_of_range& e) {
59762       {
59763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59764       };
59765     } catch (std::exception& e) {
59766       {
59767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59768       };
59769     } catch (...) {
59770       {
59771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59772       };
59773     }
59774   }
59775 }
59776
59777
59778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59779   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59780   Dali::Actor *arg2 = 0 ;
59781   SwigDirector_ViewImpl *darg = 0;
59782
59783   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59784   arg2 = (Dali::Actor *)jarg2;
59785   if (!arg2) {
59786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59787     return ;
59788   }
59789   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59790   {
59791     try {
59792       (darg)->OnChildAddSwigPublic(*arg2);
59793     } catch (std::out_of_range& e) {
59794       {
59795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59796       };
59797     } catch (std::exception& e) {
59798       {
59799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59800       };
59801     } catch (...) {
59802       {
59803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59804       };
59805     }
59806   }
59807 }
59808
59809
59810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
59811   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59812   Dali::Actor *arg2 = 0 ;
59813   SwigDirector_ViewImpl *darg = 0;
59814
59815   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59816   arg2 = (Dali::Actor *)jarg2;
59817   if (!arg2) {
59818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59819     return ;
59820   }
59821   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59822   {
59823     try {
59824       (darg)->OnChildRemove(*arg2);
59825     } catch (std::out_of_range& e) {
59826       {
59827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59828       };
59829     } catch (std::exception& e) {
59830       {
59831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59832       };
59833     } catch (...) {
59834       {
59835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59836       };
59837     }
59838   }
59839 }
59840
59841
59842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59843   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59844   Dali::Actor *arg2 = 0 ;
59845   SwigDirector_ViewImpl *darg = 0;
59846
59847   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59848   arg2 = (Dali::Actor *)jarg2;
59849   if (!arg2) {
59850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59851     return ;
59852   }
59853   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59854   {
59855     try {
59856       (darg)->OnChildRemoveSwigPublic(*arg2);
59857     } catch (std::out_of_range& e) {
59858       {
59859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59860       };
59861     } catch (std::exception& e) {
59862       {
59863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59864       };
59865     } catch (...) {
59866       {
59867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59868       };
59869     }
59870   }
59871 }
59872
59873
59874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
59875   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59876   Dali::Property::Index arg2 ;
59877   Dali::Property::Value arg3 ;
59878   Dali::Property::Value *argp3 ;
59879   SwigDirector_ViewImpl *darg = 0;
59880
59881   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59882   arg2 = (Dali::Property::Index)jarg2;
59883   argp3 = (Dali::Property::Value *)jarg3;
59884   if (!argp3) {
59885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
59886     return ;
59887   }
59888   arg3 = *argp3;
59889   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59890   {
59891     try {
59892       (darg)->OnPropertySet(arg2,arg3);
59893     } catch (std::out_of_range& e) {
59894       {
59895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59896       };
59897     } catch (std::exception& e) {
59898       {
59899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59900       };
59901     } catch (...) {
59902       {
59903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59904       };
59905     }
59906   }
59907 }
59908
59909
59910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
59911   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59912   Dali::Property::Index arg2 ;
59913   Dali::Property::Value arg3 ;
59914   Dali::Property::Value *argp3 ;
59915   SwigDirector_ViewImpl *darg = 0;
59916
59917   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59918   arg2 = (Dali::Property::Index)jarg2;
59919   argp3 = (Dali::Property::Value *)jarg3;
59920   if (!argp3) {
59921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
59922     return ;
59923   }
59924   arg3 = *argp3;
59925   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59926   {
59927     try {
59928       (darg)->OnPropertySetSwigPublic(arg2,arg3);
59929     } catch (std::out_of_range& e) {
59930       {
59931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59932       };
59933     } catch (std::exception& e) {
59934       {
59935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59936       };
59937     } catch (...) {
59938       {
59939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59940       };
59941     }
59942   }
59943 }
59944
59945
59946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
59947   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59948   Dali::Vector3 *arg2 = 0 ;
59949   SwigDirector_ViewImpl *darg = 0;
59950
59951   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59952   arg2 = (Dali::Vector3 *)jarg2;
59953   if (!arg2) {
59954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
59955     return ;
59956   }
59957   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59958   {
59959     try {
59960       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
59961     } catch (std::out_of_range& e) {
59962       {
59963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59964       };
59965     } catch (std::exception& e) {
59966       {
59967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59968       };
59969     } catch (...) {
59970       {
59971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59972       };
59973     }
59974   }
59975 }
59976
59977
59978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59979   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59980   Dali::Vector3 *arg2 = 0 ;
59981   SwigDirector_ViewImpl *darg = 0;
59982
59983   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59984   arg2 = (Dali::Vector3 *)jarg2;
59985   if (!arg2) {
59986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
59987     return ;
59988   }
59989   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59990   {
59991     try {
59992       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
59993     } catch (std::out_of_range& e) {
59994       {
59995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59996       };
59997     } catch (std::exception& e) {
59998       {
59999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60000       };
60001     } catch (...) {
60002       {
60003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60004       };
60005     }
60006   }
60007 }
60008
60009
60010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
60011   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60012   Dali::Animation *arg2 = 0 ;
60013   Dali::Vector3 *arg3 = 0 ;
60014   SwigDirector_ViewImpl *darg = 0;
60015
60016   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60017   arg2 = (Dali::Animation *)jarg2;
60018   if (!arg2) {
60019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60020     return ;
60021   }
60022   arg3 = (Dali::Vector3 *)jarg3;
60023   if (!arg3) {
60024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60025     return ;
60026   }
60027   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60028   {
60029     try {
60030       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
60031     } catch (std::out_of_range& e) {
60032       {
60033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60034       };
60035     } catch (std::exception& e) {
60036       {
60037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60038       };
60039     } catch (...) {
60040       {
60041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60042       };
60043     }
60044   }
60045 }
60046
60047
60048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60049   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60050   Dali::Animation *arg2 = 0 ;
60051   Dali::Vector3 *arg3 = 0 ;
60052   SwigDirector_ViewImpl *darg = 0;
60053
60054   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60055   arg2 = (Dali::Animation *)jarg2;
60056   if (!arg2) {
60057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60058     return ;
60059   }
60060   arg3 = (Dali::Vector3 *)jarg3;
60061   if (!arg3) {
60062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60063     return ;
60064   }
60065   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60066   {
60067     try {
60068       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
60069     } catch (std::out_of_range& e) {
60070       {
60071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60072       };
60073     } catch (std::exception& e) {
60074       {
60075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60076       };
60077     } catch (...) {
60078       {
60079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60080       };
60081     }
60082   }
60083 }
60084
60085
60086 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
60087   unsigned int jresult ;
60088   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60089   Dali::TouchEvent *arg2 = 0 ;
60090   SwigDirector_ViewImpl *darg = 0;
60091   bool result;
60092
60093   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60094   arg2 = (Dali::TouchEvent *)jarg2;
60095   if (!arg2) {
60096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
60097     return 0;
60098   }
60099   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60100   {
60101     try {
60102       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
60103     } catch (std::out_of_range& e) {
60104       {
60105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60106       };
60107     } catch (std::exception& e) {
60108       {
60109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60110       };
60111     } catch (...) {
60112       {
60113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60114       };
60115     }
60116   }
60117   jresult = result;
60118   return jresult;
60119 }
60120
60121
60122 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60123   unsigned int jresult ;
60124   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60125   Dali::TouchEvent *arg2 = 0 ;
60126   SwigDirector_ViewImpl *darg = 0;
60127   bool result;
60128
60129   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60130   arg2 = (Dali::TouchEvent *)jarg2;
60131   if (!arg2) {
60132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
60133     return 0;
60134   }
60135   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60136   {
60137     try {
60138       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
60139     } catch (std::out_of_range& e) {
60140       {
60141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60142       };
60143     } catch (std::exception& e) {
60144       {
60145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60146       };
60147     } catch (...) {
60148       {
60149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60150       };
60151     }
60152   }
60153   jresult = result;
60154   return jresult;
60155 }
60156
60157
60158 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
60159   unsigned int jresult ;
60160   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60161   Dali::HoverEvent *arg2 = 0 ;
60162   SwigDirector_ViewImpl *darg = 0;
60163   bool result;
60164
60165   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60166   arg2 = (Dali::HoverEvent *)jarg2;
60167   if (!arg2) {
60168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60169     return 0;
60170   }
60171   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60172   {
60173     try {
60174       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
60175     } catch (std::out_of_range& e) {
60176       {
60177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60178       };
60179     } catch (std::exception& e) {
60180       {
60181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60182       };
60183     } catch (...) {
60184       {
60185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60186       };
60187     }
60188   }
60189   jresult = result;
60190   return jresult;
60191 }
60192
60193
60194 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60195   unsigned int jresult ;
60196   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60197   Dali::HoverEvent *arg2 = 0 ;
60198   SwigDirector_ViewImpl *darg = 0;
60199   bool result;
60200
60201   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60202   arg2 = (Dali::HoverEvent *)jarg2;
60203   if (!arg2) {
60204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60205     return 0;
60206   }
60207   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60208   {
60209     try {
60210       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
60211     } catch (std::out_of_range& e) {
60212       {
60213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60214       };
60215     } catch (std::exception& e) {
60216       {
60217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60218       };
60219     } catch (...) {
60220       {
60221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60222       };
60223     }
60224   }
60225   jresult = result;
60226   return jresult;
60227 }
60228
60229
60230 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
60231   unsigned int jresult ;
60232   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60233   Dali::KeyEvent *arg2 = 0 ;
60234   SwigDirector_ViewImpl *darg = 0;
60235   bool result;
60236
60237   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60238   arg2 = (Dali::KeyEvent *)jarg2;
60239   if (!arg2) {
60240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60241     return 0;
60242   }
60243   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60244   {
60245     try {
60246       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
60247     } catch (std::out_of_range& e) {
60248       {
60249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60250       };
60251     } catch (std::exception& e) {
60252       {
60253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60254       };
60255     } catch (...) {
60256       {
60257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60258       };
60259     }
60260   }
60261   jresult = result;
60262   return jresult;
60263 }
60264
60265
60266 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60267   unsigned int jresult ;
60268   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60269   Dali::KeyEvent *arg2 = 0 ;
60270   SwigDirector_ViewImpl *darg = 0;
60271   bool result;
60272
60273   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60274   arg2 = (Dali::KeyEvent *)jarg2;
60275   if (!arg2) {
60276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60277     return 0;
60278   }
60279   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60280   {
60281     try {
60282       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
60283     } catch (std::out_of_range& e) {
60284       {
60285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60286       };
60287     } catch (std::exception& e) {
60288       {
60289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60290       };
60291     } catch (...) {
60292       {
60293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60294       };
60295     }
60296   }
60297   jresult = result;
60298   return jresult;
60299 }
60300
60301
60302 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
60303   unsigned int jresult ;
60304   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60305   Dali::WheelEvent *arg2 = 0 ;
60306   SwigDirector_ViewImpl *darg = 0;
60307   bool result;
60308
60309   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60310   arg2 = (Dali::WheelEvent *)jarg2;
60311   if (!arg2) {
60312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60313     return 0;
60314   }
60315   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60316   {
60317     try {
60318       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
60319     } catch (std::out_of_range& e) {
60320       {
60321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60322       };
60323     } catch (std::exception& e) {
60324       {
60325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60326       };
60327     } catch (...) {
60328       {
60329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60330       };
60331     }
60332   }
60333   jresult = result;
60334   return jresult;
60335 }
60336
60337
60338 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60339   unsigned int jresult ;
60340   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60341   Dali::WheelEvent *arg2 = 0 ;
60342   SwigDirector_ViewImpl *darg = 0;
60343   bool result;
60344
60345   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60346   arg2 = (Dali::WheelEvent *)jarg2;
60347   if (!arg2) {
60348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60349     return 0;
60350   }
60351   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60352   {
60353     try {
60354       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
60355     } catch (std::out_of_range& e) {
60356       {
60357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60358       };
60359     } catch (std::exception& e) {
60360       {
60361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60362       };
60363     } catch (...) {
60364       {
60365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60366       };
60367     }
60368   }
60369   jresult = result;
60370   return jresult;
60371 }
60372
60373
60374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
60375   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60376   Dali::Vector2 *arg2 = 0 ;
60377   Dali::RelayoutContainer *arg3 = 0 ;
60378   SwigDirector_ViewImpl *darg = 0;
60379
60380   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60381   arg2 = (Dali::Vector2 *)jarg2;
60382   if (!arg2) {
60383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60384     return ;
60385   }
60386   arg3 = (Dali::RelayoutContainer *)jarg3;
60387   if (!arg3) {
60388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60389     return ;
60390   }
60391   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60392   {
60393     try {
60394       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
60395     } catch (std::out_of_range& e) {
60396       {
60397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60398       };
60399     } catch (std::exception& e) {
60400       {
60401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60402       };
60403     } catch (...) {
60404       {
60405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60406       };
60407     }
60408   }
60409 }
60410
60411
60412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60413   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60414   Dali::Vector2 *arg2 = 0 ;
60415   Dali::RelayoutContainer *arg3 = 0 ;
60416   SwigDirector_ViewImpl *darg = 0;
60417
60418   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60419   arg2 = (Dali::Vector2 *)jarg2;
60420   if (!arg2) {
60421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60422     return ;
60423   }
60424   arg3 = (Dali::RelayoutContainer *)jarg3;
60425   if (!arg3) {
60426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60427     return ;
60428   }
60429   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60430   {
60431     try {
60432       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
60433     } catch (std::out_of_range& e) {
60434       {
60435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60436       };
60437     } catch (std::exception& e) {
60438       {
60439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60440       };
60441     } catch (...) {
60442       {
60443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60444       };
60445     }
60446   }
60447 }
60448
60449
60450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
60451   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60452   Dali::ResizePolicy::Type arg2 ;
60453   Dali::Dimension::Type arg3 ;
60454   SwigDirector_ViewImpl *darg = 0;
60455
60456   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60457   arg2 = (Dali::ResizePolicy::Type)jarg2;
60458   arg3 = (Dali::Dimension::Type)jarg3;
60459   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60460   {
60461     try {
60462       (darg)->OnSetResizePolicy(arg2,arg3);
60463     } catch (std::out_of_range& e) {
60464       {
60465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60466       };
60467     } catch (std::exception& e) {
60468       {
60469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60470       };
60471     } catch (...) {
60472       {
60473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60474       };
60475     }
60476   }
60477 }
60478
60479
60480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
60481   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60482   Dali::ResizePolicy::Type arg2 ;
60483   Dali::Dimension::Type arg3 ;
60484   SwigDirector_ViewImpl *darg = 0;
60485
60486   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60487   arg2 = (Dali::ResizePolicy::Type)jarg2;
60488   arg3 = (Dali::Dimension::Type)jarg3;
60489   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60490   {
60491     try {
60492       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
60493     } catch (std::out_of_range& e) {
60494       {
60495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60496       };
60497     } catch (std::exception& e) {
60498       {
60499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60500       };
60501     } catch (...) {
60502       {
60503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60504       };
60505     }
60506   }
60507 }
60508
60509
60510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
60511   void * jresult ;
60512   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60513   SwigDirector_ViewImpl *darg = 0;
60514   Dali::Vector3 result;
60515
60516   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60517   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60518   {
60519     try {
60520       result = (darg)->GetNaturalSize();
60521     } catch (std::out_of_range& e) {
60522       {
60523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60524       };
60525     } catch (std::exception& e) {
60526       {
60527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60528       };
60529     } catch (...) {
60530       {
60531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60532       };
60533     }
60534   }
60535   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
60536   return jresult;
60537 }
60538
60539
60540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
60541   void * jresult ;
60542   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60543   SwigDirector_ViewImpl *darg = 0;
60544   Dali::Vector3 result;
60545
60546   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60547   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60548   {
60549     try {
60550       result = (darg)->GetNaturalSizeSwigPublic();
60551     } catch (std::out_of_range& e) {
60552       {
60553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60554       };
60555     } catch (std::exception& e) {
60556       {
60557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60558       };
60559     } catch (...) {
60560       {
60561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60562       };
60563     }
60564   }
60565   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
60566   return jresult;
60567 }
60568
60569
60570 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
60571   float jresult ;
60572   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60573   Dali::Actor *arg2 = 0 ;
60574   Dali::Dimension::Type arg3 ;
60575   SwigDirector_ViewImpl *darg = 0;
60576   float result;
60577
60578   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60579   arg2 = (Dali::Actor *)jarg2;
60580   if (!arg2) {
60581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
60582     return 0;
60583   }
60584   arg3 = (Dali::Dimension::Type)jarg3;
60585   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60586   {
60587     try {
60588       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
60589     } catch (std::out_of_range& e) {
60590       {
60591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60592       };
60593     } catch (std::exception& e) {
60594       {
60595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60596       };
60597     } catch (...) {
60598       {
60599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60600       };
60601     }
60602   }
60603   jresult = result;
60604   return jresult;
60605 }
60606
60607
60608 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
60609   float jresult ;
60610   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60611   Dali::Actor *arg2 = 0 ;
60612   Dali::Dimension::Type arg3 ;
60613   SwigDirector_ViewImpl *darg = 0;
60614   float result;
60615
60616   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60617   arg2 = (Dali::Actor *)jarg2;
60618   if (!arg2) {
60619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
60620     return 0;
60621   }
60622   arg3 = (Dali::Dimension::Type)jarg3;
60623   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60624   {
60625     try {
60626       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
60627     } catch (std::out_of_range& e) {
60628       {
60629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60630       };
60631     } catch (std::exception& e) {
60632       {
60633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60634       };
60635     } catch (...) {
60636       {
60637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60638       };
60639     }
60640   }
60641   jresult = result;
60642   return jresult;
60643 }
60644
60645
60646 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
60647   float jresult ;
60648   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60649   float arg2 ;
60650   SwigDirector_ViewImpl *darg = 0;
60651   float result;
60652
60653   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60654   arg2 = (float)jarg2;
60655   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60656   {
60657     try {
60658       result = (float)(darg)->GetHeightForWidth(arg2);
60659     } catch (std::out_of_range& e) {
60660       {
60661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60662       };
60663     } catch (std::exception& e) {
60664       {
60665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60666       };
60667     } catch (...) {
60668       {
60669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60670       };
60671     }
60672   }
60673   jresult = result;
60674   return jresult;
60675 }
60676
60677
60678 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
60679   float jresult ;
60680   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60681   float arg2 ;
60682   SwigDirector_ViewImpl *darg = 0;
60683   float result;
60684
60685   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60686   arg2 = (float)jarg2;
60687   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60688   {
60689     try {
60690       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
60691     } catch (std::out_of_range& e) {
60692       {
60693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60694       };
60695     } catch (std::exception& e) {
60696       {
60697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60698       };
60699     } catch (...) {
60700       {
60701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60702       };
60703     }
60704   }
60705   jresult = result;
60706   return jresult;
60707 }
60708
60709
60710 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
60711   float jresult ;
60712   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60713   float arg2 ;
60714   SwigDirector_ViewImpl *darg = 0;
60715   float result;
60716
60717   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60718   arg2 = (float)jarg2;
60719   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60720   {
60721     try {
60722       result = (float)(darg)->GetWidthForHeight(arg2);
60723     } catch (std::out_of_range& e) {
60724       {
60725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60726       };
60727     } catch (std::exception& e) {
60728       {
60729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60730       };
60731     } catch (...) {
60732       {
60733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60734       };
60735     }
60736   }
60737   jresult = result;
60738   return jresult;
60739 }
60740
60741
60742 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
60743   float jresult ;
60744   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60745   float arg2 ;
60746   SwigDirector_ViewImpl *darg = 0;
60747   float result;
60748
60749   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60750   arg2 = (float)jarg2;
60751   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60752   {
60753     try {
60754       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
60755     } catch (std::out_of_range& e) {
60756       {
60757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60758       };
60759     } catch (std::exception& e) {
60760       {
60761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60762       };
60763     } catch (...) {
60764       {
60765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60766       };
60767     }
60768   }
60769   jresult = result;
60770   return jresult;
60771 }
60772
60773
60774 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
60775   unsigned int jresult ;
60776   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60777   Dali::Dimension::Type arg2 ;
60778   SwigDirector_ViewImpl *darg = 0;
60779   bool result;
60780
60781   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60782   arg2 = (Dali::Dimension::Type)jarg2;
60783   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60784   {
60785     try {
60786       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
60787     } catch (std::out_of_range& e) {
60788       {
60789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60790       };
60791     } catch (std::exception& e) {
60792       {
60793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60794       };
60795     } catch (...) {
60796       {
60797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60798       };
60799     }
60800   }
60801   jresult = result;
60802   return jresult;
60803 }
60804
60805
60806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
60807   unsigned int jresult ;
60808   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60809   Dali::Dimension::Type arg2 ;
60810   SwigDirector_ViewImpl *darg = 0;
60811   bool result;
60812
60813   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60814   arg2 = (Dali::Dimension::Type)jarg2;
60815   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60816   {
60817     try {
60818       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
60819     } catch (std::out_of_range& e) {
60820       {
60821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60822       };
60823     } catch (std::exception& e) {
60824       {
60825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60826       };
60827     } catch (...) {
60828       {
60829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60830       };
60831     }
60832   }
60833   jresult = result;
60834   return jresult;
60835 }
60836
60837
60838 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
60839   unsigned int jresult ;
60840   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60841   SwigDirector_ViewImpl *darg = 0;
60842   bool result;
60843
60844   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60845   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60846   {
60847     try {
60848       result = (bool)(darg)->RelayoutDependentOnChildren();
60849     } catch (std::out_of_range& e) {
60850       {
60851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60852       };
60853     } catch (std::exception& e) {
60854       {
60855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60856       };
60857     } catch (...) {
60858       {
60859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60860       };
60861     }
60862   }
60863   jresult = result;
60864   return jresult;
60865 }
60866
60867
60868 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
60869   unsigned int jresult ;
60870   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60871   SwigDirector_ViewImpl *darg = 0;
60872   bool result;
60873
60874   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60875   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60876   {
60877     try {
60878       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
60879     } catch (std::out_of_range& e) {
60880       {
60881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60882       };
60883     } catch (std::exception& e) {
60884       {
60885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60886       };
60887     } catch (...) {
60888       {
60889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60890       };
60891     }
60892   }
60893   jresult = result;
60894   return jresult;
60895 }
60896
60897
60898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
60899   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60900   Dali::Dimension::Type arg2 ;
60901   SwigDirector_ViewImpl *darg = 0;
60902
60903   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60904   arg2 = (Dali::Dimension::Type)jarg2;
60905   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60906   {
60907     try {
60908       (darg)->OnCalculateRelayoutSize(arg2);
60909     } catch (std::out_of_range& e) {
60910       {
60911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60912       };
60913     } catch (std::exception& e) {
60914       {
60915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60916       };
60917     } catch (...) {
60918       {
60919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60920       };
60921     }
60922   }
60923 }
60924
60925
60926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
60927   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60928   Dali::Dimension::Type arg2 ;
60929   SwigDirector_ViewImpl *darg = 0;
60930
60931   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60932   arg2 = (Dali::Dimension::Type)jarg2;
60933   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60934   {
60935     try {
60936       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
60937     } catch (std::out_of_range& e) {
60938       {
60939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60940       };
60941     } catch (std::exception& e) {
60942       {
60943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60944       };
60945     } catch (...) {
60946       {
60947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60948       };
60949     }
60950   }
60951 }
60952
60953
60954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
60955   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60956   float arg2 ;
60957   Dali::Dimension::Type arg3 ;
60958   SwigDirector_ViewImpl *darg = 0;
60959
60960   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60961   arg2 = (float)jarg2;
60962   arg3 = (Dali::Dimension::Type)jarg3;
60963   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60964   {
60965     try {
60966       (darg)->OnLayoutNegotiated(arg2,arg3);
60967     } catch (std::out_of_range& e) {
60968       {
60969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60970       };
60971     } catch (std::exception& e) {
60972       {
60973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60974       };
60975     } catch (...) {
60976       {
60977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60978       };
60979     }
60980   }
60981 }
60982
60983
60984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
60985   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60986   float arg2 ;
60987   Dali::Dimension::Type arg3 ;
60988   SwigDirector_ViewImpl *darg = 0;
60989
60990   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60991   arg2 = (float)jarg2;
60992   arg3 = (Dali::Dimension::Type)jarg3;
60993   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60994   {
60995     try {
60996       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
60997     } catch (std::out_of_range& e) {
60998       {
60999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61000       };
61001     } catch (std::exception& e) {
61002       {
61003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61004       };
61005     } catch (...) {
61006       {
61007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61008       };
61009     }
61010   }
61011 }
61012
61013
61014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
61015   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61016
61017   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61018   {
61019     try {
61020       (arg1)->OnInitialize();
61021     } catch (std::out_of_range& e) {
61022       {
61023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61024       };
61025     } catch (std::exception& e) {
61026       {
61027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61028       };
61029     } catch (...) {
61030       {
61031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61032       };
61033     }
61034   }
61035 }
61036
61037
61038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
61039   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61040
61041   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61042   {
61043     try {
61044       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
61045     } catch (std::out_of_range& e) {
61046       {
61047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61048       };
61049     } catch (std::exception& e) {
61050       {
61051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61052       };
61053     } catch (...) {
61054       {
61055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61056       };
61057     }
61058   }
61059 }
61060
61061
61062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
61063   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61064   Dali::Actor *arg2 = 0 ;
61065
61066   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61067   arg2 = (Dali::Actor *)jarg2;
61068   if (!arg2) {
61069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61070     return ;
61071   }
61072   {
61073     try {
61074       (arg1)->OnControlChildAdd(*arg2);
61075     } catch (std::out_of_range& e) {
61076       {
61077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61078       };
61079     } catch (std::exception& e) {
61080       {
61081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61082       };
61083     } catch (...) {
61084       {
61085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61086       };
61087     }
61088   }
61089 }
61090
61091
61092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61093   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61094   Dali::Actor *arg2 = 0 ;
61095
61096   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61097   arg2 = (Dali::Actor *)jarg2;
61098   if (!arg2) {
61099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61100     return ;
61101   }
61102   {
61103     try {
61104       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
61105     } catch (std::out_of_range& e) {
61106       {
61107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61108       };
61109     } catch (std::exception& e) {
61110       {
61111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61112       };
61113     } catch (...) {
61114       {
61115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61116       };
61117     }
61118   }
61119 }
61120
61121
61122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
61123   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61124   Dali::Actor *arg2 = 0 ;
61125
61126   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61127   arg2 = (Dali::Actor *)jarg2;
61128   if (!arg2) {
61129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61130     return ;
61131   }
61132   {
61133     try {
61134       (arg1)->OnControlChildRemove(*arg2);
61135     } catch (std::out_of_range& e) {
61136       {
61137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61138       };
61139     } catch (std::exception& e) {
61140       {
61141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61142       };
61143     } catch (...) {
61144       {
61145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61146       };
61147     }
61148   }
61149 }
61150
61151
61152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61153   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61154   Dali::Actor *arg2 = 0 ;
61155
61156   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61157   arg2 = (Dali::Actor *)jarg2;
61158   if (!arg2) {
61159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61160     return ;
61161   }
61162   {
61163     try {
61164       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
61165     } catch (std::out_of_range& e) {
61166       {
61167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61168       };
61169     } catch (std::exception& e) {
61170       {
61171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61172       };
61173     } catch (...) {
61174       {
61175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61176       };
61177     }
61178   }
61179 }
61180
61181
61182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
61183   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61184   Dali::Toolkit::StyleManager arg2 ;
61185   Dali::StyleChange::Type arg3 ;
61186   Dali::Toolkit::StyleManager *argp2 ;
61187
61188   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61189   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61190   if (!argp2) {
61191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61192     return ;
61193   }
61194   arg2 = *argp2;
61195   arg3 = (Dali::StyleChange::Type)jarg3;
61196   {
61197     try {
61198       (arg1)->OnStyleChange(arg2,arg3);
61199     } catch (std::out_of_range& e) {
61200       {
61201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61202       };
61203     } catch (std::exception& e) {
61204       {
61205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61206       };
61207     } catch (...) {
61208       {
61209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61210       };
61211     }
61212   }
61213 }
61214
61215
61216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61217   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61218   Dali::Toolkit::StyleManager arg2 ;
61219   Dali::StyleChange::Type arg3 ;
61220   Dali::Toolkit::StyleManager *argp2 ;
61221
61222   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61223   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61224   if (!argp2) {
61225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61226     return ;
61227   }
61228   arg2 = *argp2;
61229   arg3 = (Dali::StyleChange::Type)jarg3;
61230   {
61231     try {
61232       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
61233     } catch (std::out_of_range& e) {
61234       {
61235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61236       };
61237     } catch (std::exception& e) {
61238       {
61239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61240       };
61241     } catch (...) {
61242       {
61243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61244       };
61245     }
61246   }
61247 }
61248
61249
61250 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
61251   unsigned int jresult ;
61252   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61253   bool result;
61254
61255   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61256   {
61257     try {
61258       result = (bool)(arg1)->OnAccessibilityActivated();
61259     } catch (std::out_of_range& e) {
61260       {
61261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61262       };
61263     } catch (std::exception& e) {
61264       {
61265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61266       };
61267     } catch (...) {
61268       {
61269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61270       };
61271     }
61272   }
61273   jresult = result;
61274   return jresult;
61275 }
61276
61277
61278 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
61279   unsigned int jresult ;
61280   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61281   bool result;
61282
61283   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61284   {
61285     try {
61286       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
61287     } catch (std::out_of_range& e) {
61288       {
61289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61290       };
61291     } catch (std::exception& e) {
61292       {
61293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61294       };
61295     } catch (...) {
61296       {
61297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61298       };
61299     }
61300   }
61301   jresult = result;
61302   return jresult;
61303 }
61304
61305
61306 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
61307   unsigned int jresult ;
61308   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61309   Dali::PanGesture arg2 ;
61310   Dali::PanGesture *argp2 ;
61311   bool result;
61312
61313   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61314   argp2 = (Dali::PanGesture *)jarg2;
61315   if (!argp2) {
61316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61317     return 0;
61318   }
61319   arg2 = *argp2;
61320   {
61321     try {
61322       result = (bool)(arg1)->OnAccessibilityPan(arg2);
61323     } catch (std::out_of_range& e) {
61324       {
61325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61326       };
61327     } catch (std::exception& e) {
61328       {
61329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61330       };
61331     } catch (...) {
61332       {
61333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61334       };
61335     }
61336   }
61337   jresult = result;
61338   return jresult;
61339 }
61340
61341
61342 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61343   unsigned int jresult ;
61344   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61345   Dali::PanGesture arg2 ;
61346   Dali::PanGesture *argp2 ;
61347   bool result;
61348
61349   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61350   argp2 = (Dali::PanGesture *)jarg2;
61351   if (!argp2) {
61352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61353     return 0;
61354   }
61355   arg2 = *argp2;
61356   {
61357     try {
61358       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
61359     } catch (std::out_of_range& e) {
61360       {
61361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61362       };
61363     } catch (std::exception& e) {
61364       {
61365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61366       };
61367     } catch (...) {
61368       {
61369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61370       };
61371     }
61372   }
61373   jresult = result;
61374   return jresult;
61375 }
61376
61377
61378 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
61379   unsigned int jresult ;
61380   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61381   Dali::TouchEvent *arg2 = 0 ;
61382   bool result;
61383
61384   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61385   arg2 = (Dali::TouchEvent *)jarg2;
61386   if (!arg2) {
61387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61388     return 0;
61389   }
61390   {
61391     try {
61392       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
61393     } catch (std::out_of_range& e) {
61394       {
61395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61396       };
61397     } catch (std::exception& e) {
61398       {
61399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61400       };
61401     } catch (...) {
61402       {
61403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61404       };
61405     }
61406   }
61407   jresult = result;
61408   return jresult;
61409 }
61410
61411
61412 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61413   unsigned int jresult ;
61414   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61415   Dali::TouchEvent *arg2 = 0 ;
61416   bool result;
61417
61418   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61419   arg2 = (Dali::TouchEvent *)jarg2;
61420   if (!arg2) {
61421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61422     return 0;
61423   }
61424   {
61425     try {
61426       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
61427     } catch (std::out_of_range& e) {
61428       {
61429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61430       };
61431     } catch (std::exception& e) {
61432       {
61433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61434       };
61435     } catch (...) {
61436       {
61437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61438       };
61439     }
61440   }
61441   jresult = result;
61442   return jresult;
61443 }
61444
61445
61446 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
61447   unsigned int jresult ;
61448   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61449   bool arg2 ;
61450   bool result;
61451
61452   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61453   arg2 = jarg2 ? true : false;
61454   {
61455     try {
61456       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
61457     } catch (std::out_of_range& e) {
61458       {
61459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61460       };
61461     } catch (std::exception& e) {
61462       {
61463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61464       };
61465     } catch (...) {
61466       {
61467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61468       };
61469     }
61470   }
61471   jresult = result;
61472   return jresult;
61473 }
61474
61475
61476 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
61477   unsigned int jresult ;
61478   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61479   bool arg2 ;
61480   bool result;
61481
61482   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61483   arg2 = jarg2 ? true : false;
61484   {
61485     try {
61486       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
61487     } catch (std::out_of_range& e) {
61488       {
61489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61490       };
61491     } catch (std::exception& e) {
61492       {
61493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61494       };
61495     } catch (...) {
61496       {
61497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61498       };
61499     }
61500   }
61501   jresult = result;
61502   return jresult;
61503 }
61504
61505
61506 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
61507   unsigned int jresult ;
61508   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61509   bool result;
61510
61511   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61512   {
61513     try {
61514       result = (bool)(arg1)->OnAccessibilityZoom();
61515     } catch (std::out_of_range& e) {
61516       {
61517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61518       };
61519     } catch (std::exception& e) {
61520       {
61521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61522       };
61523     } catch (...) {
61524       {
61525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61526       };
61527     }
61528   }
61529   jresult = result;
61530   return jresult;
61531 }
61532
61533
61534 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
61535   unsigned int jresult ;
61536   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61537   bool result;
61538
61539   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61540   {
61541     try {
61542       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
61543     } catch (std::out_of_range& e) {
61544       {
61545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61546       };
61547     } catch (std::exception& e) {
61548       {
61549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61550       };
61551     } catch (...) {
61552       {
61553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61554       };
61555     }
61556   }
61557   jresult = result;
61558   return jresult;
61559 }
61560
61561
61562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
61563   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61564
61565   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61566   {
61567     try {
61568       (arg1)->OnKeyInputFocusGained();
61569     } catch (std::out_of_range& e) {
61570       {
61571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61572       };
61573     } catch (std::exception& e) {
61574       {
61575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61576       };
61577     } catch (...) {
61578       {
61579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61580       };
61581     }
61582   }
61583 }
61584
61585
61586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
61587   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61588
61589   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61590   {
61591     try {
61592       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
61593     } catch (std::out_of_range& e) {
61594       {
61595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61596       };
61597     } catch (std::exception& e) {
61598       {
61599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61600       };
61601     } catch (...) {
61602       {
61603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61604       };
61605     }
61606   }
61607 }
61608
61609
61610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
61611   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61612
61613   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61614   {
61615     try {
61616       (arg1)->OnKeyInputFocusLost();
61617     } catch (std::out_of_range& e) {
61618       {
61619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61620       };
61621     } catch (std::exception& e) {
61622       {
61623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61624       };
61625     } catch (...) {
61626       {
61627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61628       };
61629     }
61630   }
61631 }
61632
61633
61634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
61635   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61636
61637   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61638   {
61639     try {
61640       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
61641     } catch (std::out_of_range& e) {
61642       {
61643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61644       };
61645     } catch (std::exception& e) {
61646       {
61647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61648       };
61649     } catch (...) {
61650       {
61651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61652       };
61653     }
61654   }
61655 }
61656
61657
61658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
61659   void * jresult ;
61660   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61661   Dali::Actor arg2 ;
61662   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
61663   bool arg4 ;
61664   Dali::Actor *argp2 ;
61665   Dali::Actor result;
61666
61667   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61668   argp2 = (Dali::Actor *)jarg2;
61669   if (!argp2) {
61670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61671     return 0;
61672   }
61673   arg2 = *argp2;
61674   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
61675   arg4 = jarg4 ? true : false;
61676   {
61677     try {
61678       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
61679     } catch (std::out_of_range& e) {
61680       {
61681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61682       };
61683     } catch (std::exception& e) {
61684       {
61685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61686       };
61687     } catch (...) {
61688       {
61689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61690       };
61691     }
61692   }
61693   jresult = new Dali::Actor((const Dali::Actor &)result);
61694   return jresult;
61695 }
61696
61697
61698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
61699   void * jresult ;
61700   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61701   Dali::Actor arg2 ;
61702   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
61703   bool arg4 ;
61704   Dali::Actor *argp2 ;
61705   Dali::Actor result;
61706
61707   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61708   argp2 = (Dali::Actor *)jarg2;
61709   if (!argp2) {
61710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61711     return 0;
61712   }
61713   arg2 = *argp2;
61714   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
61715   arg4 = jarg4 ? true : false;
61716   {
61717     try {
61718       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
61719     } catch (std::out_of_range& e) {
61720       {
61721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61722       };
61723     } catch (std::exception& e) {
61724       {
61725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61726       };
61727     } catch (...) {
61728       {
61729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61730       };
61731     }
61732   }
61733   jresult = new Dali::Actor((const Dali::Actor &)result);
61734   return jresult;
61735 }
61736
61737
61738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
61739   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61740   Dali::Actor arg2 ;
61741   Dali::Actor *argp2 ;
61742
61743   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61744   argp2 = (Dali::Actor *)jarg2;
61745   if (!argp2) {
61746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61747     return ;
61748   }
61749   arg2 = *argp2;
61750   {
61751     try {
61752       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
61753     } catch (std::out_of_range& e) {
61754       {
61755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61756       };
61757     } catch (std::exception& e) {
61758       {
61759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61760       };
61761     } catch (...) {
61762       {
61763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61764       };
61765     }
61766   }
61767 }
61768
61769
61770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61771   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61772   Dali::Actor arg2 ;
61773   Dali::Actor *argp2 ;
61774
61775   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61776   argp2 = (Dali::Actor *)jarg2;
61777   if (!argp2) {
61778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61779     return ;
61780   }
61781   arg2 = *argp2;
61782   {
61783     try {
61784       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
61785     } catch (std::out_of_range& e) {
61786       {
61787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61788       };
61789     } catch (std::exception& e) {
61790       {
61791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61792       };
61793     } catch (...) {
61794       {
61795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61796       };
61797     }
61798   }
61799 }
61800
61801
61802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
61803   unsigned int jresult ;
61804   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61805   bool result;
61806
61807   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61808   {
61809     try {
61810       result = (bool)(arg1)->OnKeyboardEnter();
61811     } catch (std::out_of_range& e) {
61812       {
61813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61814       };
61815     } catch (std::exception& e) {
61816       {
61817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61818       };
61819     } catch (...) {
61820       {
61821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61822       };
61823     }
61824   }
61825   jresult = result;
61826   return jresult;
61827 }
61828
61829
61830 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
61831   unsigned int jresult ;
61832   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61833   bool result;
61834
61835   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61836   {
61837     try {
61838       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
61839     } catch (std::out_of_range& e) {
61840       {
61841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61842       };
61843     } catch (std::exception& e) {
61844       {
61845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61846       };
61847     } catch (...) {
61848       {
61849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61850       };
61851     }
61852   }
61853   jresult = result;
61854   return jresult;
61855 }
61856
61857
61858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
61859   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61860   Dali::PinchGesture *arg2 = 0 ;
61861
61862   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61863   arg2 = (Dali::PinchGesture *)jarg2;
61864   if (!arg2) {
61865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
61866     return ;
61867   }
61868   {
61869     try {
61870       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
61871     } catch (std::out_of_range& e) {
61872       {
61873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61874       };
61875     } catch (std::exception& e) {
61876       {
61877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61878       };
61879     } catch (...) {
61880       {
61881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61882       };
61883     }
61884   }
61885 }
61886
61887
61888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61889   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61890   Dali::PinchGesture *arg2 = 0 ;
61891
61892   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61893   arg2 = (Dali::PinchGesture *)jarg2;
61894   if (!arg2) {
61895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
61896     return ;
61897   }
61898   {
61899     try {
61900       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
61901     } catch (std::out_of_range& e) {
61902       {
61903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61904       };
61905     } catch (std::exception& e) {
61906       {
61907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61908       };
61909     } catch (...) {
61910       {
61911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61912       };
61913     }
61914   }
61915 }
61916
61917
61918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
61919   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61920   Dali::PanGesture *arg2 = 0 ;
61921
61922   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61923   arg2 = (Dali::PanGesture *)jarg2;
61924   if (!arg2) {
61925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
61926     return ;
61927   }
61928   {
61929     try {
61930       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
61931     } catch (std::out_of_range& e) {
61932       {
61933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61934       };
61935     } catch (std::exception& e) {
61936       {
61937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61938       };
61939     } catch (...) {
61940       {
61941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61942       };
61943     }
61944   }
61945 }
61946
61947
61948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61949   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61950   Dali::PanGesture *arg2 = 0 ;
61951
61952   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61953   arg2 = (Dali::PanGesture *)jarg2;
61954   if (!arg2) {
61955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
61956     return ;
61957   }
61958   {
61959     try {
61960       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
61961     } catch (std::out_of_range& e) {
61962       {
61963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61964       };
61965     } catch (std::exception& e) {
61966       {
61967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61968       };
61969     } catch (...) {
61970       {
61971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61972       };
61973     }
61974   }
61975 }
61976
61977
61978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
61979   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61980   Dali::TapGesture *arg2 = 0 ;
61981
61982   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61983   arg2 = (Dali::TapGesture *)jarg2;
61984   if (!arg2) {
61985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
61986     return ;
61987   }
61988   {
61989     try {
61990       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
61991     } catch (std::out_of_range& e) {
61992       {
61993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61994       };
61995     } catch (std::exception& e) {
61996       {
61997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61998       };
61999     } catch (...) {
62000       {
62001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62002       };
62003     }
62004   }
62005 }
62006
62007
62008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62009   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62010   Dali::TapGesture *arg2 = 0 ;
62011
62012   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62013   arg2 = (Dali::TapGesture *)jarg2;
62014   if (!arg2) {
62015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62016     return ;
62017   }
62018   {
62019     try {
62020       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
62021     } catch (std::out_of_range& e) {
62022       {
62023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62024       };
62025     } catch (std::exception& e) {
62026       {
62027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62028       };
62029     } catch (...) {
62030       {
62031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62032       };
62033     }
62034   }
62035 }
62036
62037
62038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
62039   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62040   Dali::LongPressGesture *arg2 = 0 ;
62041
62042   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62043   arg2 = (Dali::LongPressGesture *)jarg2;
62044   if (!arg2) {
62045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62046     return ;
62047   }
62048   {
62049     try {
62050       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
62051     } catch (std::out_of_range& e) {
62052       {
62053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62054       };
62055     } catch (std::exception& e) {
62056       {
62057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62058       };
62059     } catch (...) {
62060       {
62061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62062       };
62063     }
62064   }
62065 }
62066
62067
62068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62069   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62070   Dali::LongPressGesture *arg2 = 0 ;
62071
62072   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62073   arg2 = (Dali::LongPressGesture *)jarg2;
62074   if (!arg2) {
62075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62076     return ;
62077   }
62078   {
62079     try {
62080       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
62081     } catch (std::out_of_range& e) {
62082       {
62083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62084       };
62085     } catch (std::exception& e) {
62086       {
62087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62088       };
62089     } catch (...) {
62090       {
62091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62092       };
62093     }
62094   }
62095 }
62096
62097
62098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
62099   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62100   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62101   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62102
62103   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62104   arg2 = (Dali::SlotObserver *)jarg2;
62105   arg3 = (Dali::CallbackBase *)jarg3;
62106   {
62107     try {
62108       (arg1)->SignalConnected(arg2,arg3);
62109     } catch (std::out_of_range& e) {
62110       {
62111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62112       };
62113     } catch (std::exception& e) {
62114       {
62115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62116       };
62117     } catch (...) {
62118       {
62119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62120       };
62121     }
62122   }
62123 }
62124
62125
62126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62127   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62128   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62129   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62130
62131   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62132   arg2 = (Dali::SlotObserver *)jarg2;
62133   arg3 = (Dali::CallbackBase *)jarg3;
62134   {
62135     try {
62136       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
62137     } catch (std::out_of_range& e) {
62138       {
62139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62140       };
62141     } catch (std::exception& e) {
62142       {
62143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62144       };
62145     } catch (...) {
62146       {
62147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62148       };
62149     }
62150   }
62151 }
62152
62153
62154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
62155   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62156   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62157   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62158
62159   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62160   arg2 = (Dali::SlotObserver *)jarg2;
62161   arg3 = (Dali::CallbackBase *)jarg3;
62162   {
62163     try {
62164       (arg1)->SignalDisconnected(arg2,arg3);
62165     } catch (std::out_of_range& e) {
62166       {
62167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62168       };
62169     } catch (std::exception& e) {
62170       {
62171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62172       };
62173     } catch (...) {
62174       {
62175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62176       };
62177     }
62178   }
62179 }
62180
62181
62182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62183   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62184   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62185   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62186
62187   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62188   arg2 = (Dali::SlotObserver *)jarg2;
62189   arg3 = (Dali::CallbackBase *)jarg3;
62190   {
62191     try {
62192       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
62193     } catch (std::out_of_range& e) {
62194       {
62195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62196       };
62197     } catch (std::exception& e) {
62198       {
62199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62200       };
62201     } catch (...) {
62202       {
62203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62204       };
62205     }
62206   }
62207 }
62208
62209
62210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_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) {
62211   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
62212   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
62213   if (director) {
62214     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);
62215   }
62216 }
62217
62218
62219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
62220   void * jresult ;
62221   Dali::Toolkit::Control *arg1 = 0 ;
62222   Dali::Toolkit::Internal::Control *result = 0 ;
62223
62224   arg1 = (Dali::Toolkit::Control *)jarg1;
62225   if (!arg1) {
62226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
62227     return 0;
62228   }
62229   {
62230     try {
62231       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
62232     } catch (std::out_of_range& e) {
62233       {
62234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62235       };
62236     } catch (std::exception& e) {
62237       {
62238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62239       };
62240     } catch (...) {
62241       {
62242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62243       };
62244     }
62245   }
62246   jresult = (void *)result;
62247   return jresult;
62248 }
62249
62250
62251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
62252   int jresult ;
62253   int result;
62254
62255   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
62256   jresult = (int)result;
62257   return jresult;
62258 }
62259
62260
62261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
62262   int jresult ;
62263   int result;
62264
62265   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
62266   jresult = (int)result;
62267   return jresult;
62268 }
62269
62270
62271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
62272   int jresult ;
62273   int result;
62274
62275   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
62276   jresult = (int)result;
62277   return jresult;
62278 }
62279
62280
62281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
62282   int jresult ;
62283   int result;
62284
62285   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
62286   jresult = (int)result;
62287   return jresult;
62288 }
62289
62290
62291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
62292   int jresult ;
62293   int result;
62294
62295   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
62296   jresult = (int)result;
62297   return jresult;
62298 }
62299
62300
62301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
62302   void * jresult ;
62303   Dali::Toolkit::Control::Property *result = 0 ;
62304
62305   {
62306     try {
62307       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
62308     } catch (std::out_of_range& e) {
62309       {
62310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62311       };
62312     } catch (std::exception& e) {
62313       {
62314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62315       };
62316     } catch (...) {
62317       {
62318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62319       };
62320     }
62321   }
62322   jresult = (void *)result;
62323   return jresult;
62324 }
62325
62326
62327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
62328   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
62329
62330   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
62331   {
62332     try {
62333       delete arg1;
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_new_View_KeyboardFocus() {
62352   void * jresult ;
62353   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
62354
62355   {
62356     try {
62357       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
62358     } catch (std::out_of_range& e) {
62359       {
62360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62361       };
62362     } catch (std::exception& e) {
62363       {
62364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62365       };
62366     } catch (...) {
62367       {
62368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62369       };
62370     }
62371   }
62372   jresult = (void *)result;
62373   return jresult;
62374 }
62375
62376
62377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
62378   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
62379
62380   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
62381   {
62382     try {
62383       delete arg1;
62384     } catch (std::out_of_range& e) {
62385       {
62386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62387       };
62388     } catch (std::exception& e) {
62389       {
62390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62391       };
62392     } catch (...) {
62393       {
62394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62395       };
62396     }
62397   }
62398 }
62399
62400
62401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
62402   void * jresult ;
62403   Dali::Toolkit::Control result;
62404
62405   {
62406     try {
62407       result = Dali::Toolkit::Control::New();
62408     } catch (std::out_of_range& e) {
62409       {
62410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62411       };
62412     } catch (std::exception& e) {
62413       {
62414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62415       };
62416     } catch (...) {
62417       {
62418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62419       };
62420     }
62421   }
62422   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62423   return jresult;
62424 }
62425
62426
62427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
62428   void * jresult ;
62429   Dali::Toolkit::Control *result = 0 ;
62430
62431   {
62432     try {
62433       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
62434     } catch (std::out_of_range& e) {
62435       {
62436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62437       };
62438     } catch (std::exception& e) {
62439       {
62440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62441       };
62442     } catch (...) {
62443       {
62444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62445       };
62446     }
62447   }
62448   jresult = (void *)result;
62449   return jresult;
62450 }
62451
62452
62453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
62454   void * jresult ;
62455   Dali::Toolkit::Control *arg1 = 0 ;
62456   Dali::Toolkit::Control *result = 0 ;
62457
62458   arg1 = (Dali::Toolkit::Control *)jarg1;
62459   if (!arg1) {
62460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
62461     return 0;
62462   }
62463   {
62464     try {
62465       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
62466     } catch (std::out_of_range& e) {
62467       {
62468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62469       };
62470     } catch (std::exception& e) {
62471       {
62472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62473       };
62474     } catch (...) {
62475       {
62476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62477       };
62478     }
62479   }
62480   jresult = (void *)result;
62481   return jresult;
62482 }
62483
62484
62485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
62486   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62487
62488   arg1 = (Dali::Toolkit::Control *)jarg1;
62489   {
62490     try {
62491       delete arg1;
62492     } catch (std::out_of_range& e) {
62493       {
62494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62495       };
62496     } catch (std::exception& e) {
62497       {
62498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62499       };
62500     } catch (...) {
62501       {
62502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62503       };
62504     }
62505   }
62506 }
62507
62508
62509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
62510   void * jresult ;
62511   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62512   Dali::Toolkit::Control *arg2 = 0 ;
62513   Dali::Toolkit::Control *result = 0 ;
62514
62515   arg1 = (Dali::Toolkit::Control *)jarg1;
62516   arg2 = (Dali::Toolkit::Control *)jarg2;
62517   if (!arg2) {
62518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
62519     return 0;
62520   }
62521   {
62522     try {
62523       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
62524     } catch (std::out_of_range& e) {
62525       {
62526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62527       };
62528     } catch (std::exception& e) {
62529       {
62530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62531       };
62532     } catch (...) {
62533       {
62534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62535       };
62536     }
62537   }
62538   jresult = (void *)result;
62539   return jresult;
62540 }
62541
62542
62543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
62544   void * jresult ;
62545   Dali::BaseHandle arg1 ;
62546   Dali::BaseHandle *argp1 ;
62547   Dali::Toolkit::Control result;
62548
62549   argp1 = (Dali::BaseHandle *)jarg1;
62550   if (!argp1) {
62551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62552     return 0;
62553   }
62554   arg1 = *argp1;
62555   {
62556     try {
62557       result = Dali::Toolkit::Control::DownCast(arg1);
62558     } catch (std::out_of_range& e) {
62559       {
62560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62561       };
62562     } catch (std::exception& e) {
62563       {
62564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62565       };
62566     } catch (...) {
62567       {
62568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62569       };
62570     }
62571   }
62572   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62573   return jresult;
62574 }
62575
62576
62577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
62578   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62579
62580   arg1 = (Dali::Toolkit::Control *)jarg1;
62581   {
62582     try {
62583       (arg1)->SetKeyInputFocus();
62584     } catch (std::out_of_range& e) {
62585       {
62586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62587       };
62588     } catch (std::exception& e) {
62589       {
62590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62591       };
62592     } catch (...) {
62593       {
62594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62595       };
62596     }
62597   }
62598 }
62599
62600
62601 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
62602   unsigned int jresult ;
62603   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62604   bool result;
62605
62606   arg1 = (Dali::Toolkit::Control *)jarg1;
62607   {
62608     try {
62609       result = (bool)(arg1)->HasKeyInputFocus();
62610     } catch (std::out_of_range& e) {
62611       {
62612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62613       };
62614     } catch (std::exception& e) {
62615       {
62616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62617       };
62618     } catch (...) {
62619       {
62620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62621       };
62622     }
62623   }
62624   jresult = result;
62625   return jresult;
62626 }
62627
62628
62629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
62630   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62631
62632   arg1 = (Dali::Toolkit::Control *)jarg1;
62633   {
62634     try {
62635       (arg1)->ClearKeyInputFocus();
62636     } catch (std::out_of_range& e) {
62637       {
62638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62639       };
62640     } catch (std::exception& e) {
62641       {
62642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62643       };
62644     } catch (...) {
62645       {
62646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62647       };
62648     }
62649   }
62650 }
62651
62652
62653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
62654   void * jresult ;
62655   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62656   Dali::PinchGestureDetector result;
62657
62658   arg1 = (Dali::Toolkit::Control *)jarg1;
62659   {
62660     try {
62661       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
62662     } catch (std::out_of_range& e) {
62663       {
62664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62665       };
62666     } catch (std::exception& e) {
62667       {
62668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62669       };
62670     } catch (...) {
62671       {
62672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62673       };
62674     }
62675   }
62676   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
62677   return jresult;
62678 }
62679
62680
62681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
62682   void * jresult ;
62683   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62684   Dali::PanGestureDetector result;
62685
62686   arg1 = (Dali::Toolkit::Control *)jarg1;
62687   {
62688     try {
62689       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
62690     } catch (std::out_of_range& e) {
62691       {
62692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62693       };
62694     } catch (std::exception& e) {
62695       {
62696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62697       };
62698     } catch (...) {
62699       {
62700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62701       };
62702     }
62703   }
62704   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
62705   return jresult;
62706 }
62707
62708
62709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
62710   void * jresult ;
62711   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62712   Dali::TapGestureDetector result;
62713
62714   arg1 = (Dali::Toolkit::Control *)jarg1;
62715   {
62716     try {
62717       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
62718     } catch (std::out_of_range& e) {
62719       {
62720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62721       };
62722     } catch (std::exception& e) {
62723       {
62724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62725       };
62726     } catch (...) {
62727       {
62728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62729       };
62730     }
62731   }
62732   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
62733   return jresult;
62734 }
62735
62736
62737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
62738   void * jresult ;
62739   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62740   Dali::LongPressGestureDetector result;
62741
62742   arg1 = (Dali::Toolkit::Control *)jarg1;
62743   {
62744     try {
62745       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
62746     } catch (std::out_of_range& e) {
62747       {
62748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62749       };
62750     } catch (std::exception& e) {
62751       {
62752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62753       };
62754     } catch (...) {
62755       {
62756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62757       };
62758     }
62759   }
62760   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
62761   return jresult;
62762 }
62763
62764
62765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
62766   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62767   std::string *arg2 = 0 ;
62768
62769   arg1 = (Dali::Toolkit::Control *)jarg1;
62770   if (!jarg2) {
62771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62772     return ;
62773   }
62774   std::string arg2_str(jarg2);
62775   arg2 = &arg2_str;
62776   {
62777     try {
62778       (arg1)->SetStyleName((std::string const &)*arg2);
62779     } catch (std::out_of_range& e) {
62780       {
62781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62782       };
62783     } catch (std::exception& e) {
62784       {
62785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62786       };
62787     } catch (...) {
62788       {
62789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62790       };
62791     }
62792   }
62793
62794   //argout typemap for const std::string&
62795
62796 }
62797
62798
62799 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
62800   char * jresult ;
62801   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62802   std::string *result = 0 ;
62803
62804   arg1 = (Dali::Toolkit::Control *)jarg1;
62805   {
62806     try {
62807       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
62808     } catch (std::out_of_range& e) {
62809       {
62810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62811       };
62812     } catch (std::exception& e) {
62813       {
62814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62815       };
62816     } catch (...) {
62817       {
62818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62819       };
62820     }
62821   }
62822   jresult = SWIG_csharp_string_callback(result->c_str());
62823   return jresult;
62824 }
62825
62826
62827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
62828   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62829   Dali::Vector4 *arg2 = 0 ;
62830
62831   arg1 = (Dali::Toolkit::Control *)jarg1;
62832   arg2 = (Dali::Vector4 *)jarg2;
62833   if (!arg2) {
62834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
62835     return ;
62836   }
62837   {
62838     try {
62839       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
62840     } catch (std::out_of_range& e) {
62841       {
62842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62843       };
62844     } catch (std::exception& e) {
62845       {
62846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62847       };
62848     } catch (...) {
62849       {
62850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62851       };
62852     }
62853   }
62854 }
62855
62856
62857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
62858   void * jresult ;
62859   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62860   Dali::Vector4 result;
62861
62862   arg1 = (Dali::Toolkit::Control *)jarg1;
62863   {
62864     try {
62865       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
62866     } catch (std::out_of_range& e) {
62867       {
62868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62869       };
62870     } catch (std::exception& e) {
62871       {
62872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62873       };
62874     } catch (...) {
62875       {
62876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62877       };
62878     }
62879   }
62880   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
62881   return jresult;
62882 }
62883
62884
62885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
62886   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62887   Dali::Image arg2 ;
62888   Dali::Image *argp2 ;
62889
62890   arg1 = (Dali::Toolkit::Control *)jarg1;
62891   argp2 = (Dali::Image *)jarg2;
62892   if (!argp2) {
62893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
62894     return ;
62895   }
62896   arg2 = *argp2;
62897   {
62898     try {
62899       (arg1)->SetBackgroundImage(arg2);
62900     } catch (std::out_of_range& e) {
62901       {
62902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62903       };
62904     } catch (std::exception& e) {
62905       {
62906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62907       };
62908     } catch (...) {
62909       {
62910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62911       };
62912     }
62913   }
62914 }
62915
62916
62917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
62918   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62919
62920   arg1 = (Dali::Toolkit::Control *)jarg1;
62921   {
62922     try {
62923       (arg1)->ClearBackground();
62924     } catch (std::out_of_range& e) {
62925       {
62926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62927       };
62928     } catch (std::exception& e) {
62929       {
62930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62931       };
62932     } catch (...) {
62933       {
62934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62935       };
62936     }
62937   }
62938 }
62939
62940
62941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
62942   void * jresult ;
62943   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62944   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
62945
62946   arg1 = (Dali::Toolkit::Control *)jarg1;
62947   {
62948     try {
62949       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
62950     } catch (std::out_of_range& e) {
62951       {
62952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62953       };
62954     } catch (std::exception& e) {
62955       {
62956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62957       };
62958     } catch (...) {
62959       {
62960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62961       };
62962     }
62963   }
62964   jresult = (void *)result;
62965   return jresult;
62966 }
62967
62968
62969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
62970   void * jresult ;
62971   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62972   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
62973
62974   arg1 = (Dali::Toolkit::Control *)jarg1;
62975   {
62976     try {
62977       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
62978     } catch (std::out_of_range& e) {
62979       {
62980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62981       };
62982     } catch (std::exception& e) {
62983       {
62984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62985       };
62986     } catch (...) {
62987       {
62988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62989       };
62990     }
62991   }
62992   jresult = (void *)result;
62993   return jresult;
62994 }
62995
62996
62997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
62998   void * jresult ;
62999   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63000   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63001
63002   arg1 = (Dali::Toolkit::Control *)jarg1;
63003   {
63004     try {
63005       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63006     } catch (std::out_of_range& e) {
63007       {
63008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63009       };
63010     } catch (std::exception& e) {
63011       {
63012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63013       };
63014     } catch (...) {
63015       {
63016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63017       };
63018     }
63019   }
63020   jresult = (void *)result;
63021   return jresult;
63022 }
63023
63024
63025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
63026   void * jresult ;
63027   Dali::Toolkit::Internal::Control *arg1 = 0 ;
63028   Dali::Toolkit::Control *result = 0 ;
63029
63030   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63031   if (!arg1) {
63032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
63033     return 0;
63034   }
63035   {
63036     try {
63037       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
63038     } catch (std::out_of_range& e) {
63039       {
63040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63041       };
63042     } catch (std::exception& e) {
63043       {
63044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63045       };
63046     } catch (...) {
63047       {
63048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63049       };
63050     }
63051   }
63052   jresult = (void *)result;
63053   return jresult;
63054 }
63055
63056
63057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
63058   void * jresult ;
63059   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
63060
63061   {
63062     try {
63063       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
63064     } catch (std::out_of_range& e) {
63065       {
63066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63067       };
63068     } catch (std::exception& e) {
63069       {
63070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63071       };
63072     } catch (...) {
63073       {
63074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63075       };
63076     }
63077   }
63078   jresult = (void *)result;
63079   return jresult;
63080 }
63081
63082
63083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
63084   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63085
63086   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63087   {
63088     try {
63089       delete arg1;
63090     } catch (std::out_of_range& e) {
63091       {
63092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63093       };
63094     } catch (std::exception& e) {
63095       {
63096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63097       };
63098     } catch (...) {
63099       {
63100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63101       };
63102     }
63103   }
63104 }
63105
63106
63107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
63108   void * jresult ;
63109   Dali::Toolkit::KeyInputFocusManager result;
63110
63111   {
63112     try {
63113       result = Dali::Toolkit::KeyInputFocusManager::Get();
63114     } catch (std::out_of_range& e) {
63115       {
63116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63117       };
63118     } catch (std::exception& e) {
63119       {
63120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63121       };
63122     } catch (...) {
63123       {
63124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63125       };
63126     }
63127   }
63128   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
63129   return jresult;
63130 }
63131
63132
63133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
63134   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63135   Dali::Toolkit::Control arg2 ;
63136   Dali::Toolkit::Control *argp2 ;
63137
63138   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63139   argp2 = (Dali::Toolkit::Control *)jarg2;
63140   if (!argp2) {
63141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
63142     return ;
63143   }
63144   arg2 = *argp2;
63145   {
63146     try {
63147       (arg1)->SetFocus(arg2);
63148     } catch (std::out_of_range& e) {
63149       {
63150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63151       };
63152     } catch (std::exception& e) {
63153       {
63154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63155       };
63156     } catch (...) {
63157       {
63158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63159       };
63160     }
63161   }
63162 }
63163
63164
63165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
63166   void * jresult ;
63167   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63168   Dali::Toolkit::Control result;
63169
63170   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63171   {
63172     try {
63173       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
63174     } catch (std::out_of_range& e) {
63175       {
63176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63177       };
63178     } catch (std::exception& e) {
63179       {
63180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63181       };
63182     } catch (...) {
63183       {
63184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63185       };
63186     }
63187   }
63188   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63189   return jresult;
63190 }
63191
63192
63193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
63194   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63195   Dali::Toolkit::Control arg2 ;
63196   Dali::Toolkit::Control *argp2 ;
63197
63198   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63199   argp2 = (Dali::Toolkit::Control *)jarg2;
63200   if (!argp2) {
63201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
63202     return ;
63203   }
63204   arg2 = *argp2;
63205   {
63206     try {
63207       (arg1)->RemoveFocus(arg2);
63208     } catch (std::out_of_range& e) {
63209       {
63210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63211       };
63212     } catch (std::exception& e) {
63213       {
63214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63215       };
63216     } catch (...) {
63217       {
63218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63219       };
63220     }
63221   }
63222 }
63223
63224
63225 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_IsKeyboardListener(void * jarg1, void * jarg2) {
63226   unsigned int jresult ;
63227   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63228   Dali::Toolkit::Control arg2 ;
63229   Dali::Toolkit::Control *argp2 ;
63230   bool result;
63231
63232   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63233   argp2 = (Dali::Toolkit::Control *)jarg2;
63234   if (!argp2) {
63235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
63236     return 0;
63237   }
63238   arg2 = *argp2;
63239   {
63240     try {
63241       result = (bool)(arg1)->IsKeyboardListener(arg2);
63242     } catch (std::out_of_range& e) {
63243       {
63244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63245       };
63246     } catch (std::exception& e) {
63247       {
63248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63249       };
63250     } catch (...) {
63251       {
63252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63253       };
63254     }
63255   }
63256   jresult = result;
63257   return jresult;
63258 }
63259
63260
63261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
63262   void * jresult ;
63263   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63264   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
63265
63266   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63267   {
63268     try {
63269       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
63270     } catch (std::out_of_range& e) {
63271       {
63272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63273       };
63274     } catch (std::exception& e) {
63275       {
63276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63277       };
63278     } catch (...) {
63279       {
63280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63281       };
63282     }
63283   }
63284   jresult = (void *)result;
63285   return jresult;
63286 }
63287
63288
63289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_UnhandledKeyEventSignal(void * jarg1) {
63290   void * jresult ;
63291   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63292   Dali::Toolkit::KeyInputFocusManager::UnhandledKeyEventSignalType *result = 0 ;
63293
63294   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63295   {
63296     try {
63297       result = (Dali::Toolkit::KeyInputFocusManager::UnhandledKeyEventSignalType *) &(arg1)->UnhandledKeyEventSignal();
63298     } catch (std::out_of_range& e) {
63299       {
63300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63301       };
63302     } catch (std::exception& e) {
63303       {
63304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63305       };
63306     } catch (...) {
63307       {
63308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63309       };
63310     }
63311   }
63312   jresult = (void *)result;
63313   return jresult;
63314 }
63315
63316
63317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
63318   void * jresult ;
63319   Dali::Toolkit::Alignment::Padding *result = 0 ;
63320
63321   {
63322     try {
63323       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
63324     } catch (std::out_of_range& e) {
63325       {
63326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63327       };
63328     } catch (std::exception& e) {
63329       {
63330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63331       };
63332     } catch (...) {
63333       {
63334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63335       };
63336     }
63337   }
63338   jresult = (void *)result;
63339   return jresult;
63340 }
63341
63342
63343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
63344   void * jresult ;
63345   float arg1 ;
63346   float arg2 ;
63347   float arg3 ;
63348   float arg4 ;
63349   Dali::Toolkit::Alignment::Padding *result = 0 ;
63350
63351   arg1 = (float)jarg1;
63352   arg2 = (float)jarg2;
63353   arg3 = (float)jarg3;
63354   arg4 = (float)jarg4;
63355   {
63356     try {
63357       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
63358     } catch (std::out_of_range& e) {
63359       {
63360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63361       };
63362     } catch (std::exception& e) {
63363       {
63364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63365       };
63366     } catch (...) {
63367       {
63368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63369       };
63370     }
63371   }
63372   jresult = (void *)result;
63373   return jresult;
63374 }
63375
63376
63377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
63378   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63379   float arg2 ;
63380
63381   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63382   arg2 = (float)jarg2;
63383   if (arg1) (arg1)->left = arg2;
63384 }
63385
63386
63387 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
63388   float jresult ;
63389   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63390   float result;
63391
63392   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63393   result = (float) ((arg1)->left);
63394   jresult = result;
63395   return jresult;
63396 }
63397
63398
63399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
63400   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63401   float arg2 ;
63402
63403   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63404   arg2 = (float)jarg2;
63405   if (arg1) (arg1)->right = arg2;
63406 }
63407
63408
63409 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
63410   float jresult ;
63411   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63412   float result;
63413
63414   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63415   result = (float) ((arg1)->right);
63416   jresult = result;
63417   return jresult;
63418 }
63419
63420
63421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
63422   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63423   float arg2 ;
63424
63425   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63426   arg2 = (float)jarg2;
63427   if (arg1) (arg1)->top = arg2;
63428 }
63429
63430
63431 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
63432   float jresult ;
63433   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63434   float result;
63435
63436   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63437   result = (float) ((arg1)->top);
63438   jresult = result;
63439   return jresult;
63440 }
63441
63442
63443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
63444   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63445   float arg2 ;
63446
63447   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63448   arg2 = (float)jarg2;
63449   if (arg1) (arg1)->bottom = arg2;
63450 }
63451
63452
63453 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
63454   float jresult ;
63455   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63456   float result;
63457
63458   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63459   result = (float) ((arg1)->bottom);
63460   jresult = result;
63461   return jresult;
63462 }
63463
63464
63465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
63466   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63467
63468   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63469   {
63470     try {
63471       delete arg1;
63472     } catch (std::out_of_range& e) {
63473       {
63474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63475       };
63476     } catch (std::exception& e) {
63477       {
63478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63479       };
63480     } catch (...) {
63481       {
63482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63483       };
63484     }
63485   }
63486 }
63487
63488
63489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
63490   void * jresult ;
63491   Dali::Toolkit::Alignment *result = 0 ;
63492
63493   {
63494     try {
63495       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
63496     } catch (std::out_of_range& e) {
63497       {
63498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63499       };
63500     } catch (std::exception& e) {
63501       {
63502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63503       };
63504     } catch (...) {
63505       {
63506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63507       };
63508     }
63509   }
63510   jresult = (void *)result;
63511   return jresult;
63512 }
63513
63514
63515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
63516   void * jresult ;
63517   Dali::Toolkit::Alignment::Type arg1 ;
63518   Dali::Toolkit::Alignment::Type arg2 ;
63519   Dali::Toolkit::Alignment result;
63520
63521   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
63522   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
63523   {
63524     try {
63525       result = Dali::Toolkit::Alignment::New(arg1,arg2);
63526     } catch (std::out_of_range& e) {
63527       {
63528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63529       };
63530     } catch (std::exception& e) {
63531       {
63532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63533       };
63534     } catch (...) {
63535       {
63536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63537       };
63538     }
63539   }
63540   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63541   return jresult;
63542 }
63543
63544
63545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
63546   void * jresult ;
63547   Dali::Toolkit::Alignment::Type arg1 ;
63548   Dali::Toolkit::Alignment result;
63549
63550   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
63551   {
63552     try {
63553       result = Dali::Toolkit::Alignment::New(arg1);
63554     } catch (std::out_of_range& e) {
63555       {
63556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63557       };
63558     } catch (std::exception& e) {
63559       {
63560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63561       };
63562     } catch (...) {
63563       {
63564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63565       };
63566     }
63567   }
63568   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63569   return jresult;
63570 }
63571
63572
63573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
63574   void * jresult ;
63575   Dali::Toolkit::Alignment result;
63576
63577   {
63578     try {
63579       result = Dali::Toolkit::Alignment::New();
63580     } catch (std::out_of_range& e) {
63581       {
63582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63583       };
63584     } catch (std::exception& e) {
63585       {
63586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63587       };
63588     } catch (...) {
63589       {
63590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63591       };
63592     }
63593   }
63594   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63595   return jresult;
63596 }
63597
63598
63599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
63600   void * jresult ;
63601   Dali::Toolkit::Alignment *arg1 = 0 ;
63602   Dali::Toolkit::Alignment *result = 0 ;
63603
63604   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63605   if (!arg1) {
63606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
63607     return 0;
63608   }
63609   {
63610     try {
63611       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
63612     } catch (std::out_of_range& e) {
63613       {
63614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63615       };
63616     } catch (std::exception& e) {
63617       {
63618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63619       };
63620     } catch (...) {
63621       {
63622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63623       };
63624     }
63625   }
63626   jresult = (void *)result;
63627   return jresult;
63628 }
63629
63630
63631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
63632   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63633
63634   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63635   {
63636     try {
63637       delete arg1;
63638     } catch (std::out_of_range& e) {
63639       {
63640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63641       };
63642     } catch (std::exception& e) {
63643       {
63644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63645       };
63646     } catch (...) {
63647       {
63648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63649       };
63650     }
63651   }
63652 }
63653
63654
63655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
63656   void * jresult ;
63657   Dali::BaseHandle arg1 ;
63658   Dali::BaseHandle *argp1 ;
63659   Dali::Toolkit::Alignment result;
63660
63661   argp1 = (Dali::BaseHandle *)jarg1;
63662   if (!argp1) {
63663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63664     return 0;
63665   }
63666   arg1 = *argp1;
63667   {
63668     try {
63669       result = Dali::Toolkit::Alignment::DownCast(arg1);
63670     } catch (std::out_of_range& e) {
63671       {
63672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63673       };
63674     } catch (std::exception& e) {
63675       {
63676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63677       };
63678     } catch (...) {
63679       {
63680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63681       };
63682     }
63683   }
63684   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63685   return jresult;
63686 }
63687
63688
63689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
63690   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63691   Dali::Toolkit::Alignment::Type arg2 ;
63692
63693   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63694   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
63695   {
63696     try {
63697       (arg1)->SetAlignmentType(arg2);
63698     } catch (std::out_of_range& e) {
63699       {
63700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63701       };
63702     } catch (std::exception& e) {
63703       {
63704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63705       };
63706     } catch (...) {
63707       {
63708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63709       };
63710     }
63711   }
63712 }
63713
63714
63715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
63716   int jresult ;
63717   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63718   Dali::Toolkit::Alignment::Type result;
63719
63720   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63721   {
63722     try {
63723       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
63724     } catch (std::out_of_range& e) {
63725       {
63726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63727       };
63728     } catch (std::exception& e) {
63729       {
63730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63731       };
63732     } catch (...) {
63733       {
63734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63735       };
63736     }
63737   }
63738   jresult = (int)result;
63739   return jresult;
63740 }
63741
63742
63743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
63744   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63745   Dali::Toolkit::Alignment::Scaling arg2 ;
63746
63747   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63748   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
63749   {
63750     try {
63751       (arg1)->SetScaling(arg2);
63752     } catch (std::out_of_range& e) {
63753       {
63754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63755       };
63756     } catch (std::exception& e) {
63757       {
63758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63759       };
63760     } catch (...) {
63761       {
63762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63763       };
63764     }
63765   }
63766 }
63767
63768
63769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
63770   int jresult ;
63771   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63772   Dali::Toolkit::Alignment::Scaling result;
63773
63774   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63775   {
63776     try {
63777       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
63778     } catch (std::out_of_range& e) {
63779       {
63780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63781       };
63782     } catch (std::exception& e) {
63783       {
63784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63785       };
63786     } catch (...) {
63787       {
63788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63789       };
63790     }
63791   }
63792   jresult = (int)result;
63793   return jresult;
63794 }
63795
63796
63797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
63798   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63799   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
63800
63801   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63802   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
63803   if (!arg2) {
63804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
63805     return ;
63806   }
63807   {
63808     try {
63809       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
63810     } catch (std::out_of_range& e) {
63811       {
63812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63813       };
63814     } catch (std::exception& e) {
63815       {
63816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63817       };
63818     } catch (...) {
63819       {
63820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63821       };
63822     }
63823   }
63824 }
63825
63826
63827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
63828   void * jresult ;
63829   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63830   Dali::Toolkit::Alignment::Padding *result = 0 ;
63831
63832   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63833   {
63834     try {
63835       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
63836     } catch (std::out_of_range& e) {
63837       {
63838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63839       };
63840     } catch (std::exception& e) {
63841       {
63842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63843       };
63844     } catch (...) {
63845       {
63846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63847       };
63848     }
63849   }
63850   jresult = (void *)result;
63851   return jresult;
63852 }
63853
63854
63855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
63856   void * jresult ;
63857   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63858   Dali::Toolkit::Alignment *arg2 = 0 ;
63859   Dali::Toolkit::Alignment *result = 0 ;
63860
63861   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63862   arg2 = (Dali::Toolkit::Alignment *)jarg2;
63863   if (!arg2) {
63864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
63865     return 0;
63866   }
63867   {
63868     try {
63869       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
63870     } catch (std::out_of_range& e) {
63871       {
63872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63873       };
63874     } catch (std::exception& e) {
63875       {
63876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63877       };
63878     } catch (...) {
63879       {
63880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63881       };
63882     }
63883   }
63884   jresult = (void *)result;
63885   return jresult;
63886 }
63887
63888
63889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
63890   int jresult ;
63891   int result;
63892
63893   result = (int)Dali::Toolkit::Button::Property::DISABLED;
63894   jresult = (int)result;
63895   return jresult;
63896 }
63897
63898
63899 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
63900   int jresult ;
63901   int result;
63902
63903   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
63904   jresult = (int)result;
63905   return jresult;
63906 }
63907
63908
63909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
63910   int jresult ;
63911   int result;
63912
63913   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
63914   jresult = (int)result;
63915   return jresult;
63916 }
63917
63918
63919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
63920   int jresult ;
63921   int result;
63922
63923   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
63924   jresult = (int)result;
63925   return jresult;
63926 }
63927
63928
63929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
63930   int jresult ;
63931   int result;
63932
63933   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
63934   jresult = (int)result;
63935   return jresult;
63936 }
63937
63938
63939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
63940   int jresult ;
63941   int result;
63942
63943   result = (int)Dali::Toolkit::Button::Property::SELECTED;
63944   jresult = (int)result;
63945   return jresult;
63946 }
63947
63948
63949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_STATE_IMAGE_get() {
63950   int jresult ;
63951   int result;
63952
63953   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_STATE_IMAGE;
63954   jresult = (int)result;
63955   return jresult;
63956 }
63957
63958
63959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_STATE_IMAGE_get() {
63960   int jresult ;
63961   int result;
63962
63963   result = (int)Dali::Toolkit::Button::Property::SELECTED_STATE_IMAGE;
63964   jresult = (int)result;
63965   return jresult;
63966 }
63967
63968
63969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_STATE_IMAGE_get() {
63970   int jresult ;
63971   int result;
63972
63973   result = (int)Dali::Toolkit::Button::Property::DISABLED_STATE_IMAGE;
63974   jresult = (int)result;
63975   return jresult;
63976 }
63977
63978
63979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
63980   int jresult ;
63981   int result;
63982
63983   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
63984   jresult = (int)result;
63985   return jresult;
63986 }
63987
63988
63989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
63990   int jresult ;
63991   int result;
63992
63993   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
63994   jresult = (int)result;
63995   return jresult;
63996 }
63997
63998
63999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
64000   int jresult ;
64001   int result;
64002
64003   result = (int)Dali::Toolkit::Button::Property::LABEL;
64004   jresult = (int)result;
64005   return jresult;
64006 }
64007
64008
64009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
64010   int jresult ;
64011   int result;
64012
64013   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
64014   jresult = (int)result;
64015   return jresult;
64016 }
64017
64018
64019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
64020   void * jresult ;
64021   Dali::Toolkit::Button::Property *result = 0 ;
64022
64023   {
64024     try {
64025       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
64026     } catch (std::out_of_range& e) {
64027       {
64028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64029       };
64030     } catch (std::exception& e) {
64031       {
64032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64033       };
64034     } catch (...) {
64035       {
64036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64037       };
64038     }
64039   }
64040   jresult = (void *)result;
64041   return jresult;
64042 }
64043
64044
64045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
64046   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
64047
64048   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
64049   {
64050     try {
64051       delete arg1;
64052     } catch (std::out_of_range& e) {
64053       {
64054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64055       };
64056     } catch (std::exception& e) {
64057       {
64058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64059       };
64060     } catch (...) {
64061       {
64062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64063       };
64064     }
64065   }
64066 }
64067
64068
64069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
64070   void * jresult ;
64071   Dali::Toolkit::Button *result = 0 ;
64072
64073   {
64074     try {
64075       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
64076     } catch (std::out_of_range& e) {
64077       {
64078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64079       };
64080     } catch (std::exception& e) {
64081       {
64082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64083       };
64084     } catch (...) {
64085       {
64086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64087       };
64088     }
64089   }
64090   jresult = (void *)result;
64091   return jresult;
64092 }
64093
64094
64095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
64096   void * jresult ;
64097   Dali::Toolkit::Button *arg1 = 0 ;
64098   Dali::Toolkit::Button *result = 0 ;
64099
64100   arg1 = (Dali::Toolkit::Button *)jarg1;
64101   if (!arg1) {
64102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
64103     return 0;
64104   }
64105   {
64106     try {
64107       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
64108     } catch (std::out_of_range& e) {
64109       {
64110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64111       };
64112     } catch (std::exception& e) {
64113       {
64114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64115       };
64116     } catch (...) {
64117       {
64118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64119       };
64120     }
64121   }
64122   jresult = (void *)result;
64123   return jresult;
64124 }
64125
64126
64127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
64128   void * jresult ;
64129   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64130   Dali::Toolkit::Button *arg2 = 0 ;
64131   Dali::Toolkit::Button *result = 0 ;
64132
64133   arg1 = (Dali::Toolkit::Button *)jarg1;
64134   arg2 = (Dali::Toolkit::Button *)jarg2;
64135   if (!arg2) {
64136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
64137     return 0;
64138   }
64139   {
64140     try {
64141       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
64142     } catch (std::out_of_range& e) {
64143       {
64144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64145       };
64146     } catch (std::exception& e) {
64147       {
64148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64149       };
64150     } catch (...) {
64151       {
64152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64153       };
64154     }
64155   }
64156   jresult = (void *)result;
64157   return jresult;
64158 }
64159
64160
64161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
64162   void * jresult ;
64163   Dali::BaseHandle arg1 ;
64164   Dali::BaseHandle *argp1 ;
64165   Dali::Toolkit::Button result;
64166
64167   argp1 = (Dali::BaseHandle *)jarg1;
64168   if (!argp1) {
64169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64170     return 0;
64171   }
64172   arg1 = *argp1;
64173   {
64174     try {
64175       result = Dali::Toolkit::Button::DownCast(arg1);
64176     } catch (std::out_of_range& e) {
64177       {
64178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64179       };
64180     } catch (std::exception& e) {
64181       {
64182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64183       };
64184     } catch (...) {
64185       {
64186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64187       };
64188     }
64189   }
64190   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
64191   return jresult;
64192 }
64193
64194
64195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
64196   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64197
64198   arg1 = (Dali::Toolkit::Button *)jarg1;
64199   {
64200     try {
64201       delete arg1;
64202     } catch (std::out_of_range& e) {
64203       {
64204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64205       };
64206     } catch (std::exception& e) {
64207       {
64208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64209       };
64210     } catch (...) {
64211       {
64212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64213       };
64214     }
64215   }
64216 }
64217
64218
64219 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
64220   unsigned int jresult ;
64221   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64222   bool result;
64223
64224   arg1 = (Dali::Toolkit::Button *)jarg1;
64225   {
64226     try {
64227       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
64228     } catch (std::out_of_range& e) {
64229       {
64230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64231       };
64232     } catch (std::exception& e) {
64233       {
64234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64235       };
64236     } catch (...) {
64237       {
64238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64239       };
64240     }
64241   }
64242   jresult = result;
64243   return jresult;
64244 }
64245
64246
64247 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
64248   unsigned int jresult ;
64249   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64250   bool result;
64251
64252   arg1 = (Dali::Toolkit::Button *)jarg1;
64253   {
64254     try {
64255       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
64256     } catch (std::out_of_range& e) {
64257       {
64258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64259       };
64260     } catch (std::exception& e) {
64261       {
64262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64263       };
64264     } catch (...) {
64265       {
64266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64267       };
64268     }
64269   }
64270   jresult = result;
64271   return jresult;
64272 }
64273
64274
64275 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
64276   float jresult ;
64277   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64278   float result;
64279
64280   arg1 = (Dali::Toolkit::Button *)jarg1;
64281   {
64282     try {
64283       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
64284     } catch (std::out_of_range& e) {
64285       {
64286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64287       };
64288     } catch (std::exception& e) {
64289       {
64290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64291       };
64292     } catch (...) {
64293       {
64294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64295       };
64296     }
64297   }
64298   jresult = result;
64299   return jresult;
64300 }
64301
64302
64303 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
64304   float jresult ;
64305   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64306   float result;
64307
64308   arg1 = (Dali::Toolkit::Button *)jarg1;
64309   {
64310     try {
64311       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
64312     } catch (std::out_of_range& e) {
64313       {
64314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64315       };
64316     } catch (std::exception& e) {
64317       {
64318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64319       };
64320     } catch (...) {
64321       {
64322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64323       };
64324     }
64325   }
64326   jresult = result;
64327   return jresult;
64328 }
64329
64330
64331 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
64332   unsigned int jresult ;
64333   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64334   bool result;
64335
64336   arg1 = (Dali::Toolkit::Button *)jarg1;
64337   {
64338     try {
64339       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
64340     } catch (std::out_of_range& e) {
64341       {
64342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64343       };
64344     } catch (std::exception& e) {
64345       {
64346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64347       };
64348     } catch (...) {
64349       {
64350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64351       };
64352     }
64353   }
64354   jresult = result;
64355   return jresult;
64356 }
64357
64358
64359 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
64360   unsigned int jresult ;
64361   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64362   bool result;
64363
64364   arg1 = (Dali::Toolkit::Button *)jarg1;
64365   {
64366     try {
64367       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
64368     } catch (std::out_of_range& e) {
64369       {
64370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64371       };
64372     } catch (std::exception& e) {
64373       {
64374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64375       };
64376     } catch (...) {
64377       {
64378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64379       };
64380     }
64381   }
64382   jresult = result;
64383   return jresult;
64384 }
64385
64386
64387 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
64388   float jresult ;
64389   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64390   float result;
64391
64392   arg1 = (Dali::Toolkit::Button *)jarg1;
64393   {
64394     try {
64395       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
64396     } catch (std::out_of_range& e) {
64397       {
64398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64399       };
64400     } catch (std::exception& e) {
64401       {
64402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64403       };
64404     } catch (...) {
64405       {
64406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64407       };
64408     }
64409   }
64410   jresult = result;
64411   return jresult;
64412 }
64413
64414
64415 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
64416   char * jresult ;
64417   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64418   std::string result;
64419
64420   arg1 = (Dali::Toolkit::Button *)jarg1;
64421   {
64422     try {
64423       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
64424     } catch (std::out_of_range& e) {
64425       {
64426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64427       };
64428     } catch (std::exception& e) {
64429       {
64430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64431       };
64432     } catch (...) {
64433       {
64434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64435       };
64436     }
64437   }
64438   jresult = SWIG_csharp_string_callback((&result)->c_str());
64439   return jresult;
64440 }
64441
64442
64443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
64444   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64445   Dali::Actor arg2 ;
64446   Dali::Actor *argp2 ;
64447
64448   arg1 = (Dali::Toolkit::Button *)jarg1;
64449   argp2 = (Dali::Actor *)jarg2;
64450   if (!argp2) {
64451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
64452     return ;
64453   }
64454   arg2 = *argp2;
64455   {
64456     try {
64457       (arg1)->SetLabel(arg2);
64458     } catch (std::out_of_range& e) {
64459       {
64460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64461       };
64462     } catch (std::exception& e) {
64463       {
64464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64465       };
64466     } catch (...) {
64467       {
64468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64469       };
64470     }
64471   }
64472 }
64473
64474
64475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
64476   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64477   Dali::Image arg2 ;
64478   Dali::Image *argp2 ;
64479
64480   arg1 = (Dali::Toolkit::Button *)jarg1;
64481   argp2 = (Dali::Image *)jarg2;
64482   if (!argp2) {
64483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
64484     return ;
64485   }
64486   arg2 = *argp2;
64487   {
64488     try {
64489       (arg1)->SetButtonImage(arg2);
64490     } catch (std::out_of_range& e) {
64491       {
64492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64493       };
64494     } catch (std::exception& e) {
64495       {
64496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64497       };
64498     } catch (...) {
64499       {
64500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64501       };
64502     }
64503   }
64504 }
64505
64506
64507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
64508   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64509   Dali::Image arg2 ;
64510   Dali::Image *argp2 ;
64511
64512   arg1 = (Dali::Toolkit::Button *)jarg1;
64513   argp2 = (Dali::Image *)jarg2;
64514   if (!argp2) {
64515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
64516     return ;
64517   }
64518   arg2 = *argp2;
64519   {
64520     try {
64521       (arg1)->SetSelectedImage(arg2);
64522     } catch (std::out_of_range& e) {
64523       {
64524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64525       };
64526     } catch (std::exception& e) {
64527       {
64528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64529       };
64530     } catch (...) {
64531       {
64532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64533       };
64534     }
64535   }
64536 }
64537
64538
64539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
64540   void * jresult ;
64541   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64542   Dali::Actor result;
64543
64544   arg1 = (Dali::Toolkit::Button *)jarg1;
64545   {
64546     try {
64547       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
64548     } catch (std::out_of_range& e) {
64549       {
64550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64551       };
64552     } catch (std::exception& e) {
64553       {
64554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64555       };
64556     } catch (...) {
64557       {
64558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64559       };
64560     }
64561   }
64562   jresult = new Dali::Actor((const Dali::Actor &)result);
64563   return jresult;
64564 }
64565
64566
64567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
64568   void * jresult ;
64569   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64570   Dali::Actor result;
64571
64572   arg1 = (Dali::Toolkit::Button *)jarg1;
64573   {
64574     try {
64575       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
64576     } catch (std::out_of_range& e) {
64577       {
64578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64579       };
64580     } catch (std::exception& e) {
64581       {
64582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64583       };
64584     } catch (...) {
64585       {
64586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64587       };
64588     }
64589   }
64590   jresult = new Dali::Actor((const Dali::Actor &)result);
64591   return jresult;
64592 }
64593
64594
64595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
64596   void * jresult ;
64597   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64598   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64599
64600   arg1 = (Dali::Toolkit::Button *)jarg1;
64601   {
64602     try {
64603       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
64604     } catch (std::out_of_range& e) {
64605       {
64606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64607       };
64608     } catch (std::exception& e) {
64609       {
64610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64611       };
64612     } catch (...) {
64613       {
64614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64615       };
64616     }
64617   }
64618   jresult = (void *)result;
64619   return jresult;
64620 }
64621
64622
64623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
64624   void * jresult ;
64625   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64626   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64627
64628   arg1 = (Dali::Toolkit::Button *)jarg1;
64629   {
64630     try {
64631       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
64632     } catch (std::out_of_range& e) {
64633       {
64634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64635       };
64636     } catch (std::exception& e) {
64637       {
64638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64639       };
64640     } catch (...) {
64641       {
64642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64643       };
64644     }
64645   }
64646   jresult = (void *)result;
64647   return jresult;
64648 }
64649
64650
64651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
64652   void * jresult ;
64653   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64654   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64655
64656   arg1 = (Dali::Toolkit::Button *)jarg1;
64657   {
64658     try {
64659       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
64660     } catch (std::out_of_range& e) {
64661       {
64662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64663       };
64664     } catch (std::exception& e) {
64665       {
64666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64667       };
64668     } catch (...) {
64669       {
64670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64671       };
64672     }
64673   }
64674   jresult = (void *)result;
64675   return jresult;
64676 }
64677
64678
64679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
64680   void * jresult ;
64681   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64682   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64683
64684   arg1 = (Dali::Toolkit::Button *)jarg1;
64685   {
64686     try {
64687       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
64688     } catch (std::out_of_range& e) {
64689       {
64690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64691       };
64692     } catch (std::exception& e) {
64693       {
64694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64695       };
64696     } catch (...) {
64697       {
64698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64699       };
64700     }
64701   }
64702   jresult = (void *)result;
64703   return jresult;
64704 }
64705
64706
64707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
64708   void * jresult ;
64709   Dali::Toolkit::CheckBoxButton *result = 0 ;
64710
64711   {
64712     try {
64713       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
64714     } catch (std::out_of_range& e) {
64715       {
64716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64717       };
64718     } catch (std::exception& e) {
64719       {
64720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64721       };
64722     } catch (...) {
64723       {
64724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64725       };
64726     }
64727   }
64728   jresult = (void *)result;
64729   return jresult;
64730 }
64731
64732
64733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
64734   void * jresult ;
64735   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
64736   Dali::Toolkit::CheckBoxButton *result = 0 ;
64737
64738   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
64739   if (!arg1) {
64740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
64741     return 0;
64742   }
64743   {
64744     try {
64745       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
64746     } catch (std::out_of_range& e) {
64747       {
64748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64749       };
64750     } catch (std::exception& e) {
64751       {
64752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64753       };
64754     } catch (...) {
64755       {
64756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64757       };
64758     }
64759   }
64760   jresult = (void *)result;
64761   return jresult;
64762 }
64763
64764
64765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
64766   void * jresult ;
64767   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
64768   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
64769   Dali::Toolkit::CheckBoxButton *result = 0 ;
64770
64771   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
64772   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
64773   if (!arg2) {
64774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
64775     return 0;
64776   }
64777   {
64778     try {
64779       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
64780     } catch (std::out_of_range& e) {
64781       {
64782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64783       };
64784     } catch (std::exception& e) {
64785       {
64786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64787       };
64788     } catch (...) {
64789       {
64790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64791       };
64792     }
64793   }
64794   jresult = (void *)result;
64795   return jresult;
64796 }
64797
64798
64799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
64800   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
64801
64802   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
64803   {
64804     try {
64805       delete arg1;
64806     } catch (std::out_of_range& e) {
64807       {
64808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64809       };
64810     } catch (std::exception& e) {
64811       {
64812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64813       };
64814     } catch (...) {
64815       {
64816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64817       };
64818     }
64819   }
64820 }
64821
64822
64823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
64824   void * jresult ;
64825   Dali::Toolkit::CheckBoxButton result;
64826
64827   {
64828     try {
64829       result = Dali::Toolkit::CheckBoxButton::New();
64830     } catch (std::out_of_range& e) {
64831       {
64832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64833       };
64834     } catch (std::exception& e) {
64835       {
64836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64837       };
64838     } catch (...) {
64839       {
64840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64841       };
64842     }
64843   }
64844   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
64845   return jresult;
64846 }
64847
64848
64849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
64850   void * jresult ;
64851   Dali::BaseHandle arg1 ;
64852   Dali::BaseHandle *argp1 ;
64853   Dali::Toolkit::CheckBoxButton result;
64854
64855   argp1 = (Dali::BaseHandle *)jarg1;
64856   if (!argp1) {
64857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64858     return 0;
64859   }
64860   arg1 = *argp1;
64861   {
64862     try {
64863       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
64864     } catch (std::out_of_range& e) {
64865       {
64866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64867       };
64868     } catch (std::exception& e) {
64869       {
64870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64871       };
64872     } catch (...) {
64873       {
64874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64875       };
64876     }
64877   }
64878   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
64879   return jresult;
64880 }
64881
64882
64883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
64884   int jresult ;
64885   int result;
64886
64887   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
64888   jresult = (int)result;
64889   return jresult;
64890 }
64891
64892
64893 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
64894   int jresult ;
64895   int result;
64896
64897   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
64898   jresult = (int)result;
64899   return jresult;
64900 }
64901
64902
64903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
64904   int jresult ;
64905   int result;
64906
64907   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
64908   jresult = (int)result;
64909   return jresult;
64910 }
64911
64912
64913 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
64914   int jresult ;
64915   int result;
64916
64917   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
64918   jresult = (int)result;
64919   return jresult;
64920 }
64921
64922
64923 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
64924   int jresult ;
64925   int result;
64926
64927   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
64928   jresult = (int)result;
64929   return jresult;
64930 }
64931
64932
64933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
64934   void * jresult ;
64935   Dali::Toolkit::PushButton::Property *result = 0 ;
64936
64937   {
64938     try {
64939       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
64940     } catch (std::out_of_range& e) {
64941       {
64942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64943       };
64944     } catch (std::exception& e) {
64945       {
64946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64947       };
64948     } catch (...) {
64949       {
64950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64951       };
64952     }
64953   }
64954   jresult = (void *)result;
64955   return jresult;
64956 }
64957
64958
64959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
64960   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
64961
64962   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
64963   {
64964     try {
64965       delete arg1;
64966     } catch (std::out_of_range& e) {
64967       {
64968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64969       };
64970     } catch (std::exception& e) {
64971       {
64972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64973       };
64974     } catch (...) {
64975       {
64976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64977       };
64978     }
64979   }
64980 }
64981
64982
64983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
64984   void * jresult ;
64985   Dali::Toolkit::PushButton *result = 0 ;
64986
64987   {
64988     try {
64989       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
64990     } catch (std::out_of_range& e) {
64991       {
64992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64993       };
64994     } catch (std::exception& e) {
64995       {
64996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64997       };
64998     } catch (...) {
64999       {
65000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65001       };
65002     }
65003   }
65004   jresult = (void *)result;
65005   return jresult;
65006 }
65007
65008
65009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
65010   void * jresult ;
65011   Dali::Toolkit::PushButton *arg1 = 0 ;
65012   Dali::Toolkit::PushButton *result = 0 ;
65013
65014   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65015   if (!arg1) {
65016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65017     return 0;
65018   }
65019   {
65020     try {
65021       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
65022     } catch (std::out_of_range& e) {
65023       {
65024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65025       };
65026     } catch (std::exception& e) {
65027       {
65028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65029       };
65030     } catch (...) {
65031       {
65032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65033       };
65034     }
65035   }
65036   jresult = (void *)result;
65037   return jresult;
65038 }
65039
65040
65041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
65042   void * jresult ;
65043   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65044   Dali::Toolkit::PushButton *arg2 = 0 ;
65045   Dali::Toolkit::PushButton *result = 0 ;
65046
65047   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65048   arg2 = (Dali::Toolkit::PushButton *)jarg2;
65049   if (!arg2) {
65050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65051     return 0;
65052   }
65053   {
65054     try {
65055       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
65056     } catch (std::out_of_range& e) {
65057       {
65058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65059       };
65060     } catch (std::exception& e) {
65061       {
65062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65063       };
65064     } catch (...) {
65065       {
65066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65067       };
65068     }
65069   }
65070   jresult = (void *)result;
65071   return jresult;
65072 }
65073
65074
65075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
65076   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65077
65078   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65079   {
65080     try {
65081       delete arg1;
65082     } catch (std::out_of_range& e) {
65083       {
65084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65085       };
65086     } catch (std::exception& e) {
65087       {
65088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65089       };
65090     } catch (...) {
65091       {
65092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65093       };
65094     }
65095   }
65096 }
65097
65098
65099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
65100   void * jresult ;
65101   Dali::Toolkit::PushButton result;
65102
65103   {
65104     try {
65105       result = Dali::Toolkit::PushButton::New();
65106     } catch (std::out_of_range& e) {
65107       {
65108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65109       };
65110     } catch (std::exception& e) {
65111       {
65112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65113       };
65114     } catch (...) {
65115       {
65116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65117       };
65118     }
65119   }
65120   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65121   return jresult;
65122 }
65123
65124
65125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
65126   void * jresult ;
65127   Dali::BaseHandle arg1 ;
65128   Dali::BaseHandle *argp1 ;
65129   Dali::Toolkit::PushButton result;
65130
65131   argp1 = (Dali::BaseHandle *)jarg1;
65132   if (!argp1) {
65133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65134     return 0;
65135   }
65136   arg1 = *argp1;
65137   {
65138     try {
65139       result = Dali::Toolkit::PushButton::DownCast(arg1);
65140     } catch (std::out_of_range& e) {
65141       {
65142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65143       };
65144     } catch (std::exception& e) {
65145       {
65146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65147       };
65148     } catch (...) {
65149       {
65150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65151       };
65152     }
65153   }
65154   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65155   return jresult;
65156 }
65157
65158
65159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
65160   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65161   Dali::Image arg2 ;
65162   Dali::Image *argp2 ;
65163
65164   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65165   argp2 = (Dali::Image *)jarg2;
65166   if (!argp2) {
65167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65168     return ;
65169   }
65170   arg2 = *argp2;
65171   {
65172     try {
65173       (arg1)->SetButtonImage(arg2);
65174     } catch (std::out_of_range& e) {
65175       {
65176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65177       };
65178     } catch (std::exception& e) {
65179       {
65180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65181       };
65182     } catch (...) {
65183       {
65184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65185       };
65186     }
65187   }
65188 }
65189
65190
65191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
65192   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65193   Dali::Actor arg2 ;
65194   Dali::Actor *argp2 ;
65195
65196   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65197   argp2 = (Dali::Actor *)jarg2;
65198   if (!argp2) {
65199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65200     return ;
65201   }
65202   arg2 = *argp2;
65203   {
65204     try {
65205       (arg1)->SetButtonImage(arg2);
65206     } catch (std::out_of_range& e) {
65207       {
65208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65209       };
65210     } catch (std::exception& e) {
65211       {
65212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65213       };
65214     } catch (...) {
65215       {
65216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65217       };
65218     }
65219   }
65220 }
65221
65222
65223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
65224   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65225   Dali::Actor arg2 ;
65226   Dali::Actor *argp2 ;
65227
65228   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65229   argp2 = (Dali::Actor *)jarg2;
65230   if (!argp2) {
65231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65232     return ;
65233   }
65234   arg2 = *argp2;
65235   {
65236     try {
65237       (arg1)->SetBackgroundImage(arg2);
65238     } catch (std::out_of_range& e) {
65239       {
65240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65241       };
65242     } catch (std::exception& e) {
65243       {
65244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65245       };
65246     } catch (...) {
65247       {
65248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65249       };
65250     }
65251   }
65252 }
65253
65254
65255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
65256   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65257   Dali::Image arg2 ;
65258   Dali::Image *argp2 ;
65259
65260   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65261   argp2 = (Dali::Image *)jarg2;
65262   if (!argp2) {
65263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65264     return ;
65265   }
65266   arg2 = *argp2;
65267   {
65268     try {
65269       (arg1)->SetSelectedImage(arg2);
65270     } catch (std::out_of_range& e) {
65271       {
65272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65273       };
65274     } catch (std::exception& e) {
65275       {
65276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65277       };
65278     } catch (...) {
65279       {
65280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65281       };
65282     }
65283   }
65284 }
65285
65286
65287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
65288   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65289   Dali::Actor arg2 ;
65290   Dali::Actor *argp2 ;
65291
65292   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65293   argp2 = (Dali::Actor *)jarg2;
65294   if (!argp2) {
65295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65296     return ;
65297   }
65298   arg2 = *argp2;
65299   {
65300     try {
65301       (arg1)->SetSelectedImage(arg2);
65302     } catch (std::out_of_range& e) {
65303       {
65304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65305       };
65306     } catch (std::exception& e) {
65307       {
65308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65309       };
65310     } catch (...) {
65311       {
65312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65313       };
65314     }
65315   }
65316 }
65317
65318
65319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
65320   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65321   Dali::Actor arg2 ;
65322   Dali::Actor *argp2 ;
65323
65324   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65325   argp2 = (Dali::Actor *)jarg2;
65326   if (!argp2) {
65327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65328     return ;
65329   }
65330   arg2 = *argp2;
65331   {
65332     try {
65333       (arg1)->SetSelectedBackgroundImage(arg2);
65334     } catch (std::out_of_range& e) {
65335       {
65336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65337       };
65338     } catch (std::exception& e) {
65339       {
65340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65341       };
65342     } catch (...) {
65343       {
65344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65345       };
65346     }
65347   }
65348 }
65349
65350
65351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
65352   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65353   Dali::Actor arg2 ;
65354   Dali::Actor *argp2 ;
65355
65356   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65357   argp2 = (Dali::Actor *)jarg2;
65358   if (!argp2) {
65359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65360     return ;
65361   }
65362   arg2 = *argp2;
65363   {
65364     try {
65365       (arg1)->SetDisabledBackgroundImage(arg2);
65366     } catch (std::out_of_range& e) {
65367       {
65368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65369       };
65370     } catch (std::exception& e) {
65371       {
65372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65373       };
65374     } catch (...) {
65375       {
65376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65377       };
65378     }
65379   }
65380 }
65381
65382
65383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
65384   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65385   Dali::Actor arg2 ;
65386   Dali::Actor *argp2 ;
65387
65388   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65389   argp2 = (Dali::Actor *)jarg2;
65390   if (!argp2) {
65391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65392     return ;
65393   }
65394   arg2 = *argp2;
65395   {
65396     try {
65397       (arg1)->SetDisabledImage(arg2);
65398     } catch (std::out_of_range& e) {
65399       {
65400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65401       };
65402     } catch (std::exception& e) {
65403       {
65404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65405       };
65406     } catch (...) {
65407       {
65408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65409       };
65410     }
65411   }
65412 }
65413
65414
65415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
65416   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65417   Dali::Actor arg2 ;
65418   Dali::Actor *argp2 ;
65419
65420   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65421   argp2 = (Dali::Actor *)jarg2;
65422   if (!argp2) {
65423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65424     return ;
65425   }
65426   arg2 = *argp2;
65427   {
65428     try {
65429       (arg1)->SetDisabledSelectedImage(arg2);
65430     } catch (std::out_of_range& e) {
65431       {
65432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65433       };
65434     } catch (std::exception& e) {
65435       {
65436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65437       };
65438     } catch (...) {
65439       {
65440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65441       };
65442     }
65443   }
65444 }
65445
65446
65447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
65448   void * jresult ;
65449   Dali::Toolkit::RadioButton *result = 0 ;
65450
65451   {
65452     try {
65453       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
65454     } catch (std::out_of_range& e) {
65455       {
65456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65457       };
65458     } catch (std::exception& e) {
65459       {
65460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65461       };
65462     } catch (...) {
65463       {
65464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65465       };
65466     }
65467   }
65468   jresult = (void *)result;
65469   return jresult;
65470 }
65471
65472
65473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
65474   void * jresult ;
65475   Dali::Toolkit::RadioButton *arg1 = 0 ;
65476   Dali::Toolkit::RadioButton *result = 0 ;
65477
65478   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65479   if (!arg1) {
65480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65481     return 0;
65482   }
65483   {
65484     try {
65485       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
65486     } catch (std::out_of_range& e) {
65487       {
65488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65489       };
65490     } catch (std::exception& e) {
65491       {
65492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65493       };
65494     } catch (...) {
65495       {
65496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65497       };
65498     }
65499   }
65500   jresult = (void *)result;
65501   return jresult;
65502 }
65503
65504
65505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
65506   void * jresult ;
65507   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65508   Dali::Toolkit::RadioButton *arg2 = 0 ;
65509   Dali::Toolkit::RadioButton *result = 0 ;
65510
65511   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65512   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
65513   if (!arg2) {
65514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65515     return 0;
65516   }
65517   {
65518     try {
65519       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
65520     } catch (std::out_of_range& e) {
65521       {
65522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65523       };
65524     } catch (std::exception& e) {
65525       {
65526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65527       };
65528     } catch (...) {
65529       {
65530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65531       };
65532     }
65533   }
65534   jresult = (void *)result;
65535   return jresult;
65536 }
65537
65538
65539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
65540   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65541
65542   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65543   {
65544     try {
65545       delete arg1;
65546     } catch (std::out_of_range& e) {
65547       {
65548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65549       };
65550     } catch (std::exception& e) {
65551       {
65552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65553       };
65554     } catch (...) {
65555       {
65556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65557       };
65558     }
65559   }
65560 }
65561
65562
65563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
65564   void * jresult ;
65565   Dali::Toolkit::RadioButton result;
65566
65567   {
65568     try {
65569       result = Dali::Toolkit::RadioButton::New();
65570     } catch (std::out_of_range& e) {
65571       {
65572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65573       };
65574     } catch (std::exception& e) {
65575       {
65576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65577       };
65578     } catch (...) {
65579       {
65580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65581       };
65582     }
65583   }
65584   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65585   return jresult;
65586 }
65587
65588
65589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
65590   void * jresult ;
65591   std::string *arg1 = 0 ;
65592   Dali::Toolkit::RadioButton result;
65593
65594   if (!jarg1) {
65595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
65596     return 0;
65597   }
65598   std::string arg1_str(jarg1);
65599   arg1 = &arg1_str;
65600   {
65601     try {
65602       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
65603     } catch (std::out_of_range& e) {
65604       {
65605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65606       };
65607     } catch (std::exception& e) {
65608       {
65609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65610       };
65611     } catch (...) {
65612       {
65613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65614       };
65615     }
65616   }
65617   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65618
65619   //argout typemap for const std::string&
65620
65621   return jresult;
65622 }
65623
65624
65625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
65626   void * jresult ;
65627   Dali::BaseHandle arg1 ;
65628   Dali::BaseHandle *argp1 ;
65629   Dali::Toolkit::RadioButton result;
65630
65631   argp1 = (Dali::BaseHandle *)jarg1;
65632   if (!argp1) {
65633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65634     return 0;
65635   }
65636   arg1 = *argp1;
65637   {
65638     try {
65639       result = Dali::Toolkit::RadioButton::DownCast(arg1);
65640     } catch (std::out_of_range& e) {
65641       {
65642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65643       };
65644     } catch (std::exception& e) {
65645       {
65646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65647       };
65648     } catch (...) {
65649       {
65650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65651       };
65652     }
65653   }
65654   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65655   return jresult;
65656 }
65657
65658
65659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
65660   int jresult ;
65661   int result;
65662
65663   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
65664   jresult = (int)result;
65665   return jresult;
65666 }
65667
65668
65669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
65670   int jresult ;
65671   int result;
65672
65673   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
65674   jresult = (int)result;
65675   return jresult;
65676 }
65677
65678
65679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
65680   int jresult ;
65681   int result;
65682
65683   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
65684   jresult = (int)result;
65685   return jresult;
65686 }
65687
65688
65689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
65690   int jresult ;
65691   int result;
65692
65693   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
65694   jresult = (int)result;
65695   return jresult;
65696 }
65697
65698
65699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
65700   int jresult ;
65701   int result;
65702
65703   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
65704   jresult = (int)result;
65705   return jresult;
65706 }
65707
65708
65709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
65710   int jresult ;
65711   int result;
65712
65713   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
65714   jresult = (int)result;
65715   return jresult;
65716 }
65717
65718
65719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
65720   void * jresult ;
65721   Dali::Toolkit::FlexContainer::Property *result = 0 ;
65722
65723   {
65724     try {
65725       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
65726     } catch (std::out_of_range& e) {
65727       {
65728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65729       };
65730     } catch (std::exception& e) {
65731       {
65732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65733       };
65734     } catch (...) {
65735       {
65736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65737       };
65738     }
65739   }
65740   jresult = (void *)result;
65741   return jresult;
65742 }
65743
65744
65745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
65746   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
65747
65748   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
65749   {
65750     try {
65751       delete arg1;
65752     } catch (std::out_of_range& e) {
65753       {
65754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65755       };
65756     } catch (std::exception& e) {
65757       {
65758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65759       };
65760     } catch (...) {
65761       {
65762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65763       };
65764     }
65765   }
65766 }
65767
65768
65769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
65770   int jresult ;
65771   int result;
65772
65773   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
65774   jresult = (int)result;
65775   return jresult;
65776 }
65777
65778
65779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
65780   int jresult ;
65781   int result;
65782
65783   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
65784   jresult = (int)result;
65785   return jresult;
65786 }
65787
65788
65789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
65790   int jresult ;
65791   int result;
65792
65793   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
65794   jresult = (int)result;
65795   return jresult;
65796 }
65797
65798
65799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
65800   void * jresult ;
65801   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
65802
65803   {
65804     try {
65805       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
65806     } catch (std::out_of_range& e) {
65807       {
65808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65809       };
65810     } catch (std::exception& e) {
65811       {
65812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65813       };
65814     } catch (...) {
65815       {
65816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65817       };
65818     }
65819   }
65820   jresult = (void *)result;
65821   return jresult;
65822 }
65823
65824
65825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
65826   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
65827
65828   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
65829   {
65830     try {
65831       delete arg1;
65832     } catch (std::out_of_range& e) {
65833       {
65834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65835       };
65836     } catch (std::exception& e) {
65837       {
65838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65839       };
65840     } catch (...) {
65841       {
65842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65843       };
65844     }
65845   }
65846 }
65847
65848
65849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
65850   void * jresult ;
65851   Dali::Toolkit::FlexContainer *result = 0 ;
65852
65853   {
65854     try {
65855       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
65856     } catch (std::out_of_range& e) {
65857       {
65858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65859       };
65860     } catch (std::exception& e) {
65861       {
65862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65863       };
65864     } catch (...) {
65865       {
65866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65867       };
65868     }
65869   }
65870   jresult = (void *)result;
65871   return jresult;
65872 }
65873
65874
65875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
65876   void * jresult ;
65877   Dali::Toolkit::FlexContainer *arg1 = 0 ;
65878   Dali::Toolkit::FlexContainer *result = 0 ;
65879
65880   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
65881   if (!arg1) {
65882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
65883     return 0;
65884   }
65885   {
65886     try {
65887       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
65888     } catch (std::out_of_range& e) {
65889       {
65890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65891       };
65892     } catch (std::exception& e) {
65893       {
65894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65895       };
65896     } catch (...) {
65897       {
65898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65899       };
65900     }
65901   }
65902   jresult = (void *)result;
65903   return jresult;
65904 }
65905
65906
65907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
65908   void * jresult ;
65909   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
65910   Dali::Toolkit::FlexContainer *arg2 = 0 ;
65911   Dali::Toolkit::FlexContainer *result = 0 ;
65912
65913   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
65914   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
65915   if (!arg2) {
65916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
65917     return 0;
65918   }
65919   {
65920     try {
65921       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
65922     } catch (std::out_of_range& e) {
65923       {
65924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65925       };
65926     } catch (std::exception& e) {
65927       {
65928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65929       };
65930     } catch (...) {
65931       {
65932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65933       };
65934     }
65935   }
65936   jresult = (void *)result;
65937   return jresult;
65938 }
65939
65940
65941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
65942   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
65943
65944   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
65945   {
65946     try {
65947       delete arg1;
65948     } catch (std::out_of_range& e) {
65949       {
65950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65951       };
65952     } catch (std::exception& e) {
65953       {
65954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65955       };
65956     } catch (...) {
65957       {
65958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65959       };
65960     }
65961   }
65962 }
65963
65964
65965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
65966   void * jresult ;
65967   Dali::Toolkit::FlexContainer result;
65968
65969   {
65970     try {
65971       result = Dali::Toolkit::FlexContainer::New();
65972     } catch (std::out_of_range& e) {
65973       {
65974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65975       };
65976     } catch (std::exception& e) {
65977       {
65978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65979       };
65980     } catch (...) {
65981       {
65982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65983       };
65984     }
65985   }
65986   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
65987   return jresult;
65988 }
65989
65990
65991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
65992   void * jresult ;
65993   Dali::BaseHandle arg1 ;
65994   Dali::BaseHandle *argp1 ;
65995   Dali::Toolkit::FlexContainer result;
65996
65997   argp1 = (Dali::BaseHandle *)jarg1;
65998   if (!argp1) {
65999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66000     return 0;
66001   }
66002   arg1 = *argp1;
66003   {
66004     try {
66005       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
66006     } catch (std::out_of_range& e) {
66007       {
66008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66009       };
66010     } catch (std::exception& e) {
66011       {
66012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66013       };
66014     } catch (...) {
66015       {
66016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66017       };
66018     }
66019   }
66020   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66021   return jresult;
66022 }
66023
66024
66025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
66026   int jresult ;
66027   int result;
66028
66029   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
66030   jresult = (int)result;
66031   return jresult;
66032 }
66033
66034
66035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
66036   int jresult ;
66037   int result;
66038
66039   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
66040   jresult = (int)result;
66041   return jresult;
66042 }
66043
66044
66045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
66046   int jresult ;
66047   int result;
66048
66049   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
66050   jresult = (int)result;
66051   return jresult;
66052 }
66053
66054
66055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
66056   int jresult ;
66057   int result;
66058
66059   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
66060   jresult = (int)result;
66061   return jresult;
66062 }
66063
66064
66065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
66066   void * jresult ;
66067   Dali::Toolkit::ImageView::Property *result = 0 ;
66068
66069   {
66070     try {
66071       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
66072     } catch (std::out_of_range& e) {
66073       {
66074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66075       };
66076     } catch (std::exception& e) {
66077       {
66078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66079       };
66080     } catch (...) {
66081       {
66082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66083       };
66084     }
66085   }
66086   jresult = (void *)result;
66087   return jresult;
66088 }
66089
66090
66091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
66092   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
66093
66094   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
66095   {
66096     try {
66097       delete arg1;
66098     } catch (std::out_of_range& e) {
66099       {
66100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66101       };
66102     } catch (std::exception& e) {
66103       {
66104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66105       };
66106     } catch (...) {
66107       {
66108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66109       };
66110     }
66111   }
66112 }
66113
66114
66115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
66116   void * jresult ;
66117   Dali::Toolkit::ImageView *result = 0 ;
66118
66119   {
66120     try {
66121       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
66122     } catch (std::out_of_range& e) {
66123       {
66124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66125       };
66126     } catch (std::exception& e) {
66127       {
66128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66129       };
66130     } catch (...) {
66131       {
66132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66133       };
66134     }
66135   }
66136   jresult = (void *)result;
66137   return jresult;
66138 }
66139
66140
66141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
66142   void * jresult ;
66143   Dali::Toolkit::ImageView result;
66144
66145   {
66146     try {
66147       result = Dali::Toolkit::ImageView::New();
66148     } catch (std::out_of_range& e) {
66149       {
66150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66151       };
66152     } catch (std::exception& e) {
66153       {
66154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66155       };
66156     } catch (...) {
66157       {
66158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66159       };
66160     }
66161   }
66162   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66163   return jresult;
66164 }
66165
66166
66167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
66168   void * jresult ;
66169   Dali::Image arg1 ;
66170   Dali::Image *argp1 ;
66171   Dali::Toolkit::ImageView result;
66172
66173   argp1 = (Dali::Image *)jarg1;
66174   if (!argp1) {
66175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
66176     return 0;
66177   }
66178   arg1 = *argp1;
66179   {
66180     try {
66181       result = Dali::Toolkit::ImageView::New(arg1);
66182     } catch (std::out_of_range& e) {
66183       {
66184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66185       };
66186     } catch (std::exception& e) {
66187       {
66188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66189       };
66190     } catch (...) {
66191       {
66192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66193       };
66194     }
66195   }
66196   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66197   return jresult;
66198 }
66199
66200
66201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
66202   void * jresult ;
66203   std::string *arg1 = 0 ;
66204   Dali::Toolkit::ImageView result;
66205
66206   if (!jarg1) {
66207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66208     return 0;
66209   }
66210   std::string arg1_str(jarg1);
66211   arg1 = &arg1_str;
66212   {
66213     try {
66214       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
66215     } catch (std::out_of_range& e) {
66216       {
66217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66218       };
66219     } catch (std::exception& e) {
66220       {
66221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66222       };
66223     } catch (...) {
66224       {
66225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66226       };
66227     }
66228   }
66229   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66230
66231   //argout typemap for const std::string&
66232
66233   return jresult;
66234 }
66235
66236
66237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
66238   void * jresult ;
66239   std::string *arg1 = 0 ;
66240   Dali::ImageDimensions arg2 ;
66241   Dali::ImageDimensions *argp2 ;
66242   Dali::Toolkit::ImageView result;
66243
66244   if (!jarg1) {
66245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66246     return 0;
66247   }
66248   std::string arg1_str(jarg1);
66249   arg1 = &arg1_str;
66250   argp2 = (Dali::ImageDimensions *)jarg2;
66251   if (!argp2) {
66252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66253     return 0;
66254   }
66255   arg2 = *argp2;
66256   {
66257     try {
66258       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
66259     } catch (std::out_of_range& e) {
66260       {
66261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66262       };
66263     } catch (std::exception& e) {
66264       {
66265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66266       };
66267     } catch (...) {
66268       {
66269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66270       };
66271     }
66272   }
66273   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66274
66275   //argout typemap for const std::string&
66276
66277   return jresult;
66278 }
66279
66280
66281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
66282   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66283
66284   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66285   {
66286     try {
66287       delete arg1;
66288     } catch (std::out_of_range& e) {
66289       {
66290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66291       };
66292     } catch (std::exception& e) {
66293       {
66294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66295       };
66296     } catch (...) {
66297       {
66298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66299       };
66300     }
66301   }
66302 }
66303
66304
66305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
66306   void * jresult ;
66307   Dali::Toolkit::ImageView *arg1 = 0 ;
66308   Dali::Toolkit::ImageView *result = 0 ;
66309
66310   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66311   if (!arg1) {
66312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66313     return 0;
66314   }
66315   {
66316     try {
66317       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
66318     } catch (std::out_of_range& e) {
66319       {
66320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66321       };
66322     } catch (std::exception& e) {
66323       {
66324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66325       };
66326     } catch (...) {
66327       {
66328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66329       };
66330     }
66331   }
66332   jresult = (void *)result;
66333   return jresult;
66334 }
66335
66336
66337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
66338   void * jresult ;
66339   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66340   Dali::Toolkit::ImageView *arg2 = 0 ;
66341   Dali::Toolkit::ImageView *result = 0 ;
66342
66343   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66344   arg2 = (Dali::Toolkit::ImageView *)jarg2;
66345   if (!arg2) {
66346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66347     return 0;
66348   }
66349   {
66350     try {
66351       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
66352     } catch (std::out_of_range& e) {
66353       {
66354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66355       };
66356     } catch (std::exception& e) {
66357       {
66358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66359       };
66360     } catch (...) {
66361       {
66362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66363       };
66364     }
66365   }
66366   jresult = (void *)result;
66367   return jresult;
66368 }
66369
66370
66371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
66372   void * jresult ;
66373   Dali::BaseHandle arg1 ;
66374   Dali::BaseHandle *argp1 ;
66375   Dali::Toolkit::ImageView result;
66376
66377   argp1 = (Dali::BaseHandle *)jarg1;
66378   if (!argp1) {
66379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66380     return 0;
66381   }
66382   arg1 = *argp1;
66383   {
66384     try {
66385       result = Dali::Toolkit::ImageView::DownCast(arg1);
66386     } catch (std::out_of_range& e) {
66387       {
66388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66389       };
66390     } catch (std::exception& e) {
66391       {
66392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66393       };
66394     } catch (...) {
66395       {
66396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66397       };
66398     }
66399   }
66400   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66401   return jresult;
66402 }
66403
66404
66405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
66406   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66407   Dali::Image arg2 ;
66408   Dali::Image *argp2 ;
66409
66410   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66411   argp2 = (Dali::Image *)jarg2;
66412   if (!argp2) {
66413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
66414     return ;
66415   }
66416   arg2 = *argp2;
66417   {
66418     try {
66419       (arg1)->SetImage(arg2);
66420     } catch (std::out_of_range& e) {
66421       {
66422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66423       };
66424     } catch (std::exception& e) {
66425       {
66426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66427       };
66428     } catch (...) {
66429       {
66430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66431       };
66432     }
66433   }
66434 }
66435
66436
66437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
66438   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66439   std::string *arg2 = 0 ;
66440
66441   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66442   if (!jarg2) {
66443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66444     return ;
66445   }
66446   std::string arg2_str(jarg2);
66447   arg2 = &arg2_str;
66448   {
66449     try {
66450       (arg1)->SetImage((std::string const &)*arg2);
66451     } catch (std::out_of_range& e) {
66452       {
66453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66454       };
66455     } catch (std::exception& e) {
66456       {
66457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66458       };
66459     } catch (...) {
66460       {
66461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66462       };
66463     }
66464   }
66465
66466   //argout typemap for const std::string&
66467
66468 }
66469
66470
66471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
66472   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66473   std::string *arg2 = 0 ;
66474   Dali::ImageDimensions arg3 ;
66475   Dali::ImageDimensions *argp3 ;
66476
66477   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66478   if (!jarg2) {
66479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66480     return ;
66481   }
66482   std::string arg2_str(jarg2);
66483   arg2 = &arg2_str;
66484   argp3 = (Dali::ImageDimensions *)jarg3;
66485   if (!argp3) {
66486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66487     return ;
66488   }
66489   arg3 = *argp3;
66490   {
66491     try {
66492       (arg1)->SetImage((std::string const &)*arg2,arg3);
66493     } catch (std::out_of_range& e) {
66494       {
66495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66496       };
66497     } catch (std::exception& e) {
66498       {
66499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66500       };
66501     } catch (...) {
66502       {
66503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66504       };
66505     }
66506   }
66507
66508   //argout typemap for const std::string&
66509
66510 }
66511
66512
66513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
66514   void * jresult ;
66515   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66516   Dali::Image result;
66517
66518   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66519   {
66520     try {
66521       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
66522     } catch (std::out_of_range& e) {
66523       {
66524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66525       };
66526     } catch (std::exception& e) {
66527       {
66528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66529       };
66530     } catch (...) {
66531       {
66532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66533       };
66534     }
66535   }
66536   jresult = new Dali::Image((const Dali::Image &)result);
66537   return jresult;
66538 }
66539
66540
66541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
66542   int jresult ;
66543   int result;
66544
66545   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
66546   jresult = (int)result;
66547   return jresult;
66548 }
66549
66550
66551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
66552   int jresult ;
66553   int result;
66554
66555   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
66556   jresult = (int)result;
66557   return jresult;
66558 }
66559
66560
66561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
66562   int jresult ;
66563   int result;
66564
66565   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
66566   jresult = (int)result;
66567   return jresult;
66568 }
66569
66570
66571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
66572   int jresult ;
66573   int result;
66574
66575   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
66576   jresult = (int)result;
66577   return jresult;
66578 }
66579
66580
66581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
66582   int jresult ;
66583   int result;
66584
66585   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
66586   jresult = (int)result;
66587   return jresult;
66588 }
66589
66590
66591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
66592   int jresult ;
66593   int result;
66594
66595   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
66596   jresult = (int)result;
66597   return jresult;
66598 }
66599
66600
66601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
66602   int jresult ;
66603   int result;
66604
66605   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
66606   jresult = (int)result;
66607   return jresult;
66608 }
66609
66610
66611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
66612   int jresult ;
66613   int result;
66614
66615   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
66616   jresult = (int)result;
66617   return jresult;
66618 }
66619
66620
66621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
66622   void * jresult ;
66623   Dali::Toolkit::Model3dView::Property *result = 0 ;
66624
66625   {
66626     try {
66627       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
66628     } catch (std::out_of_range& e) {
66629       {
66630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66631       };
66632     } catch (std::exception& e) {
66633       {
66634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66635       };
66636     } catch (...) {
66637       {
66638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66639       };
66640     }
66641   }
66642   jresult = (void *)result;
66643   return jresult;
66644 }
66645
66646
66647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
66648   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
66649
66650   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
66651   {
66652     try {
66653       delete arg1;
66654     } catch (std::out_of_range& e) {
66655       {
66656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66657       };
66658     } catch (std::exception& e) {
66659       {
66660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66661       };
66662     } catch (...) {
66663       {
66664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66665       };
66666     }
66667   }
66668 }
66669
66670
66671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
66672   void * jresult ;
66673   Dali::Toolkit::Model3dView result;
66674
66675   {
66676     try {
66677       result = Dali::Toolkit::Model3dView::New();
66678     } catch (std::out_of_range& e) {
66679       {
66680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66681       };
66682     } catch (std::exception& e) {
66683       {
66684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66685       };
66686     } catch (...) {
66687       {
66688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66689       };
66690     }
66691   }
66692   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
66693   return jresult;
66694 }
66695
66696
66697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
66698   void * jresult ;
66699   std::string *arg1 = 0 ;
66700   std::string *arg2 = 0 ;
66701   std::string *arg3 = 0 ;
66702   Dali::Toolkit::Model3dView result;
66703
66704   if (!jarg1) {
66705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66706     return 0;
66707   }
66708   std::string arg1_str(jarg1);
66709   arg1 = &arg1_str;
66710   if (!jarg2) {
66711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66712     return 0;
66713   }
66714   std::string arg2_str(jarg2);
66715   arg2 = &arg2_str;
66716   if (!jarg3) {
66717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66718     return 0;
66719   }
66720   std::string arg3_str(jarg3);
66721   arg3 = &arg3_str;
66722   {
66723     try {
66724       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
66725     } catch (std::out_of_range& e) {
66726       {
66727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66728       };
66729     } catch (std::exception& e) {
66730       {
66731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66732       };
66733     } catch (...) {
66734       {
66735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66736       };
66737     }
66738   }
66739   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
66740
66741   //argout typemap for const std::string&
66742
66743
66744   //argout typemap for const std::string&
66745
66746
66747   //argout typemap for const std::string&
66748
66749   return jresult;
66750 }
66751
66752
66753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
66754   void * jresult ;
66755   Dali::Toolkit::Model3dView *result = 0 ;
66756
66757   {
66758     try {
66759       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
66760     } catch (std::out_of_range& e) {
66761       {
66762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66763       };
66764     } catch (std::exception& e) {
66765       {
66766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66767       };
66768     } catch (...) {
66769       {
66770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66771       };
66772     }
66773   }
66774   jresult = (void *)result;
66775   return jresult;
66776 }
66777
66778
66779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
66780   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
66781
66782   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
66783   {
66784     try {
66785       delete arg1;
66786     } catch (std::out_of_range& e) {
66787       {
66788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66789       };
66790     } catch (std::exception& e) {
66791       {
66792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66793       };
66794     } catch (...) {
66795       {
66796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66797       };
66798     }
66799   }
66800 }
66801
66802
66803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
66804   void * jresult ;
66805   Dali::Toolkit::Model3dView *arg1 = 0 ;
66806   Dali::Toolkit::Model3dView *result = 0 ;
66807
66808   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
66809   if (!arg1) {
66810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
66811     return 0;
66812   }
66813   {
66814     try {
66815       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
66816     } catch (std::out_of_range& e) {
66817       {
66818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66819       };
66820     } catch (std::exception& e) {
66821       {
66822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66823       };
66824     } catch (...) {
66825       {
66826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66827       };
66828     }
66829   }
66830   jresult = (void *)result;
66831   return jresult;
66832 }
66833
66834
66835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
66836   void * jresult ;
66837   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
66838   Dali::Toolkit::Model3dView *arg2 = 0 ;
66839   Dali::Toolkit::Model3dView *result = 0 ;
66840
66841   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
66842   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
66843   if (!arg2) {
66844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
66845     return 0;
66846   }
66847   {
66848     try {
66849       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
66850     } catch (std::out_of_range& e) {
66851       {
66852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66853       };
66854     } catch (std::exception& e) {
66855       {
66856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66857       };
66858     } catch (...) {
66859       {
66860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66861       };
66862     }
66863   }
66864   jresult = (void *)result;
66865   return jresult;
66866 }
66867
66868
66869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
66870   void * jresult ;
66871   Dali::BaseHandle arg1 ;
66872   Dali::BaseHandle *argp1 ;
66873   Dali::Toolkit::Model3dView result;
66874
66875   argp1 = (Dali::BaseHandle *)jarg1;
66876   if (!argp1) {
66877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66878     return 0;
66879   }
66880   arg1 = *argp1;
66881   {
66882     try {
66883       result = Dali::Toolkit::Model3dView::DownCast(arg1);
66884     } catch (std::out_of_range& e) {
66885       {
66886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66887       };
66888     } catch (std::exception& e) {
66889       {
66890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66891       };
66892     } catch (...) {
66893       {
66894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66895       };
66896     }
66897   }
66898   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
66899   return jresult;
66900 }
66901
66902
66903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
66904   int jresult ;
66905   int result;
66906
66907   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
66908   jresult = (int)result;
66909   return jresult;
66910 }
66911
66912
66913 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
66914   int jresult ;
66915   int result;
66916
66917   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
66918   jresult = (int)result;
66919   return jresult;
66920 }
66921
66922
66923 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
66924   int jresult ;
66925   int result;
66926
66927   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
66928   jresult = (int)result;
66929   return jresult;
66930 }
66931
66932
66933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
66934   int jresult ;
66935   int result;
66936
66937   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
66938   jresult = (int)result;
66939   return jresult;
66940 }
66941
66942
66943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
66944   int jresult ;
66945   int result;
66946
66947   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
66948   jresult = (int)result;
66949   return jresult;
66950 }
66951
66952
66953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
66954   int jresult ;
66955   int result;
66956
66957   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
66958   jresult = (int)result;
66959   return jresult;
66960 }
66961
66962
66963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
66964   int jresult ;
66965   int result;
66966
66967   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
66968   jresult = (int)result;
66969   return jresult;
66970 }
66971
66972
66973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
66974   int jresult ;
66975   int result;
66976
66977   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
66978   jresult = (int)result;
66979   return jresult;
66980 }
66981
66982
66983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
66984   int jresult ;
66985   int result;
66986
66987   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
66988   jresult = (int)result;
66989   return jresult;
66990 }
66991
66992
66993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
66994   void * jresult ;
66995   Dali::Toolkit::ScrollBar::Property *result = 0 ;
66996
66997   {
66998     try {
66999       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
67000     } catch (std::out_of_range& e) {
67001       {
67002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67003       };
67004     } catch (std::exception& e) {
67005       {
67006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67007       };
67008     } catch (...) {
67009       {
67010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67011       };
67012     }
67013   }
67014   jresult = (void *)result;
67015   return jresult;
67016 }
67017
67018
67019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
67020   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
67021
67022   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
67023   {
67024     try {
67025       delete arg1;
67026     } catch (std::out_of_range& e) {
67027       {
67028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67029       };
67030     } catch (std::exception& e) {
67031       {
67032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67033       };
67034     } catch (...) {
67035       {
67036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67037       };
67038     }
67039   }
67040 }
67041
67042
67043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
67044   void * jresult ;
67045   Dali::Toolkit::ScrollBar *result = 0 ;
67046
67047   {
67048     try {
67049       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
67050     } catch (std::out_of_range& e) {
67051       {
67052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67053       };
67054     } catch (std::exception& e) {
67055       {
67056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67057       };
67058     } catch (...) {
67059       {
67060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67061       };
67062     }
67063   }
67064   jresult = (void *)result;
67065   return jresult;
67066 }
67067
67068
67069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
67070   void * jresult ;
67071   Dali::Toolkit::ScrollBar *arg1 = 0 ;
67072   Dali::Toolkit::ScrollBar *result = 0 ;
67073
67074   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67075   if (!arg1) {
67076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67077     return 0;
67078   }
67079   {
67080     try {
67081       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
67082     } catch (std::out_of_range& e) {
67083       {
67084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67085       };
67086     } catch (std::exception& e) {
67087       {
67088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67089       };
67090     } catch (...) {
67091       {
67092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67093       };
67094     }
67095   }
67096   jresult = (void *)result;
67097   return jresult;
67098 }
67099
67100
67101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
67102   void * jresult ;
67103   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67104   Dali::Toolkit::ScrollBar *arg2 = 0 ;
67105   Dali::Toolkit::ScrollBar *result = 0 ;
67106
67107   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67108   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
67109   if (!arg2) {
67110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67111     return 0;
67112   }
67113   {
67114     try {
67115       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
67116     } catch (std::out_of_range& e) {
67117       {
67118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67119       };
67120     } catch (std::exception& e) {
67121       {
67122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67123       };
67124     } catch (...) {
67125       {
67126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67127       };
67128     }
67129   }
67130   jresult = (void *)result;
67131   return jresult;
67132 }
67133
67134
67135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
67136   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67137
67138   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67139   {
67140     try {
67141       delete arg1;
67142     } catch (std::out_of_range& e) {
67143       {
67144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67145       };
67146     } catch (std::exception& e) {
67147       {
67148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67149       };
67150     } catch (...) {
67151       {
67152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67153       };
67154     }
67155   }
67156 }
67157
67158
67159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
67160   void * jresult ;
67161   Dali::Toolkit::ScrollBar::Direction arg1 ;
67162   Dali::Toolkit::ScrollBar result;
67163
67164   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
67165   {
67166     try {
67167       result = Dali::Toolkit::ScrollBar::New(arg1);
67168     } catch (std::out_of_range& e) {
67169       {
67170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67171       };
67172     } catch (std::exception& e) {
67173       {
67174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67175       };
67176     } catch (...) {
67177       {
67178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67179       };
67180     }
67181   }
67182   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67183   return jresult;
67184 }
67185
67186
67187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
67188   void * jresult ;
67189   Dali::Toolkit::ScrollBar result;
67190
67191   {
67192     try {
67193       result = Dali::Toolkit::ScrollBar::New();
67194     } catch (std::out_of_range& e) {
67195       {
67196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67197       };
67198     } catch (std::exception& e) {
67199       {
67200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67201       };
67202     } catch (...) {
67203       {
67204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67205       };
67206     }
67207   }
67208   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67209   return jresult;
67210 }
67211
67212
67213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
67214   void * jresult ;
67215   Dali::BaseHandle arg1 ;
67216   Dali::BaseHandle *argp1 ;
67217   Dali::Toolkit::ScrollBar result;
67218
67219   argp1 = (Dali::BaseHandle *)jarg1;
67220   if (!argp1) {
67221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67222     return 0;
67223   }
67224   arg1 = *argp1;
67225   {
67226     try {
67227       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
67228     } catch (std::out_of_range& e) {
67229       {
67230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67231       };
67232     } catch (std::exception& e) {
67233       {
67234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67235       };
67236     } catch (...) {
67237       {
67238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67239       };
67240     }
67241   }
67242   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67243   return jresult;
67244 }
67245
67246
67247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
67248   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67249   Dali::Handle arg2 ;
67250   Dali::Property::Index arg3 ;
67251   Dali::Property::Index arg4 ;
67252   Dali::Property::Index arg5 ;
67253   Dali::Property::Index arg6 ;
67254   Dali::Handle *argp2 ;
67255
67256   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67257   argp2 = (Dali::Handle *)jarg2;
67258   if (!argp2) {
67259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
67260     return ;
67261   }
67262   arg2 = *argp2;
67263   arg3 = (Dali::Property::Index)jarg3;
67264   arg4 = (Dali::Property::Index)jarg4;
67265   arg5 = (Dali::Property::Index)jarg5;
67266   arg6 = (Dali::Property::Index)jarg6;
67267   {
67268     try {
67269       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
67270     } catch (std::out_of_range& e) {
67271       {
67272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67273       };
67274     } catch (std::exception& e) {
67275       {
67276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67277       };
67278     } catch (...) {
67279       {
67280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67281       };
67282     }
67283   }
67284 }
67285
67286
67287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
67288   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67289   Dali::Actor arg2 ;
67290   Dali::Actor *argp2 ;
67291
67292   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67293   argp2 = (Dali::Actor *)jarg2;
67294   if (!argp2) {
67295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
67296     return ;
67297   }
67298   arg2 = *argp2;
67299   {
67300     try {
67301       (arg1)->SetScrollIndicator(arg2);
67302     } catch (std::out_of_range& e) {
67303       {
67304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67305       };
67306     } catch (std::exception& e) {
67307       {
67308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67309       };
67310     } catch (...) {
67311       {
67312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67313       };
67314     }
67315   }
67316 }
67317
67318
67319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
67320   void * jresult ;
67321   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67322   Dali::Actor result;
67323
67324   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67325   {
67326     try {
67327       result = (arg1)->GetScrollIndicator();
67328     } catch (std::out_of_range& e) {
67329       {
67330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67331       };
67332     } catch (std::exception& e) {
67333       {
67334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67335       };
67336     } catch (...) {
67337       {
67338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67339       };
67340     }
67341   }
67342   jresult = new Dali::Actor((const Dali::Actor &)result);
67343   return jresult;
67344 }
67345
67346
67347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
67348   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67349   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
67350
67351   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67352   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
67353   if (!arg2) {
67354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
67355     return ;
67356   }
67357   {
67358     try {
67359       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
67360     } catch (std::out_of_range& e) {
67361       {
67362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67363       };
67364     } catch (std::exception& e) {
67365       {
67366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67367       };
67368     } catch (...) {
67369       {
67370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67371       };
67372     }
67373   }
67374 }
67375
67376
67377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
67378   void * jresult ;
67379   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67380   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > result;
67381
67382   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67383   {
67384     try {
67385       result = ((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollPositionIntervals();
67386     } catch (std::out_of_range& e) {
67387       {
67388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67389       };
67390     } catch (std::exception& e) {
67391       {
67392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67393       };
67394     } catch (...) {
67395       {
67396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67397       };
67398     }
67399   }
67400   jresult = new Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true >((const Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > &)result);
67401   return jresult;
67402 }
67403
67404
67405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
67406   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67407   Dali::Toolkit::ScrollBar::Direction arg2 ;
67408
67409   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67410   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
67411   {
67412     try {
67413       (arg1)->SetScrollDirection(arg2);
67414     } catch (std::out_of_range& e) {
67415       {
67416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67417       };
67418     } catch (std::exception& e) {
67419       {
67420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67421       };
67422     } catch (...) {
67423       {
67424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67425       };
67426     }
67427   }
67428 }
67429
67430
67431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
67432   int jresult ;
67433   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67434   Dali::Toolkit::ScrollBar::Direction result;
67435
67436   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67437   {
67438     try {
67439       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
67440     } catch (std::out_of_range& e) {
67441       {
67442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67443       };
67444     } catch (std::exception& e) {
67445       {
67446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67447       };
67448     } catch (...) {
67449       {
67450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67451       };
67452     }
67453   }
67454   jresult = (int)result;
67455   return jresult;
67456 }
67457
67458
67459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
67460   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67461   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
67462
67463   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67464   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
67465   {
67466     try {
67467       (arg1)->SetIndicatorHeightPolicy(arg2);
67468     } catch (std::out_of_range& e) {
67469       {
67470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67471       };
67472     } catch (std::exception& e) {
67473       {
67474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67475       };
67476     } catch (...) {
67477       {
67478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67479       };
67480     }
67481   }
67482 }
67483
67484
67485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
67486   int jresult ;
67487   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67488   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
67489
67490   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67491   {
67492     try {
67493       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
67494     } catch (std::out_of_range& e) {
67495       {
67496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67497       };
67498     } catch (std::exception& e) {
67499       {
67500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67501       };
67502     } catch (...) {
67503       {
67504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67505       };
67506     }
67507   }
67508   jresult = (int)result;
67509   return jresult;
67510 }
67511
67512
67513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
67514   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67515   float arg2 ;
67516
67517   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67518   arg2 = (float)jarg2;
67519   {
67520     try {
67521       (arg1)->SetIndicatorFixedHeight(arg2);
67522     } catch (std::out_of_range& e) {
67523       {
67524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67525       };
67526     } catch (std::exception& e) {
67527       {
67528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67529       };
67530     } catch (...) {
67531       {
67532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67533       };
67534     }
67535   }
67536 }
67537
67538
67539 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
67540   float jresult ;
67541   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67542   float result;
67543
67544   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67545   {
67546     try {
67547       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
67548     } catch (std::out_of_range& e) {
67549       {
67550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67551       };
67552     } catch (std::exception& e) {
67553       {
67554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67555       };
67556     } catch (...) {
67557       {
67558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67559       };
67560     }
67561   }
67562   jresult = result;
67563   return jresult;
67564 }
67565
67566
67567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
67568   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67569   float arg2 ;
67570
67571   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67572   arg2 = (float)jarg2;
67573   {
67574     try {
67575       (arg1)->SetIndicatorShowDuration(arg2);
67576     } catch (std::out_of_range& e) {
67577       {
67578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67579       };
67580     } catch (std::exception& e) {
67581       {
67582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67583       };
67584     } catch (...) {
67585       {
67586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67587       };
67588     }
67589   }
67590 }
67591
67592
67593 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
67594   float jresult ;
67595   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67596   float result;
67597
67598   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67599   {
67600     try {
67601       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
67602     } catch (std::out_of_range& e) {
67603       {
67604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67605       };
67606     } catch (std::exception& e) {
67607       {
67608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67609       };
67610     } catch (...) {
67611       {
67612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67613       };
67614     }
67615   }
67616   jresult = result;
67617   return jresult;
67618 }
67619
67620
67621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
67622   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67623   float arg2 ;
67624
67625   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67626   arg2 = (float)jarg2;
67627   {
67628     try {
67629       (arg1)->SetIndicatorHideDuration(arg2);
67630     } catch (std::out_of_range& e) {
67631       {
67632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67633       };
67634     } catch (std::exception& e) {
67635       {
67636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67637       };
67638     } catch (...) {
67639       {
67640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67641       };
67642     }
67643   }
67644 }
67645
67646
67647 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
67648   float jresult ;
67649   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67650   float result;
67651
67652   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67653   {
67654     try {
67655       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
67656     } catch (std::out_of_range& e) {
67657       {
67658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67659       };
67660     } catch (std::exception& e) {
67661       {
67662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67663       };
67664     } catch (...) {
67665       {
67666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67667       };
67668     }
67669   }
67670   jresult = result;
67671   return jresult;
67672 }
67673
67674
67675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
67676   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67677
67678   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67679   {
67680     try {
67681       (arg1)->ShowIndicator();
67682     } catch (std::out_of_range& e) {
67683       {
67684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67685       };
67686     } catch (std::exception& e) {
67687       {
67688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67689       };
67690     } catch (...) {
67691       {
67692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67693       };
67694     }
67695   }
67696 }
67697
67698
67699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
67700   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67701
67702   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67703   {
67704     try {
67705       (arg1)->HideIndicator();
67706     } catch (std::out_of_range& e) {
67707       {
67708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67709       };
67710     } catch (std::exception& e) {
67711       {
67712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67713       };
67714     } catch (...) {
67715       {
67716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67717       };
67718     }
67719   }
67720 }
67721
67722
67723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
67724   void * jresult ;
67725   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67726   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
67727
67728   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67729   {
67730     try {
67731       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
67732     } catch (std::out_of_range& e) {
67733       {
67734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67735       };
67736     } catch (std::exception& e) {
67737       {
67738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67739       };
67740     } catch (...) {
67741       {
67742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67743       };
67744     }
67745   }
67746   jresult = (void *)result;
67747   return jresult;
67748 }
67749
67750
67751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
67752   void * jresult ;
67753   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67754   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
67755
67756   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67757   {
67758     try {
67759       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
67760     } catch (std::out_of_range& e) {
67761       {
67762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67763       };
67764     } catch (std::exception& e) {
67765       {
67766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67767       };
67768     } catch (...) {
67769       {
67770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67771       };
67772     }
67773   }
67774   jresult = (void *)result;
67775   return jresult;
67776 }
67777
67778
67779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
67780   int jresult ;
67781   int result;
67782
67783   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
67784   jresult = (int)result;
67785   return jresult;
67786 }
67787
67788
67789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
67790   int jresult ;
67791   int result;
67792
67793   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
67794   jresult = (int)result;
67795   return jresult;
67796 }
67797
67798
67799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
67800   int jresult ;
67801   int result;
67802
67803   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
67804   jresult = (int)result;
67805   return jresult;
67806 }
67807
67808
67809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
67810   int jresult ;
67811   int result;
67812
67813   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
67814   jresult = (int)result;
67815   return jresult;
67816 }
67817
67818
67819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
67820   int jresult ;
67821   int result;
67822
67823   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
67824   jresult = (int)result;
67825   return jresult;
67826 }
67827
67828
67829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
67830   int jresult ;
67831   int result;
67832
67833   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
67834   jresult = (int)result;
67835   return jresult;
67836 }
67837
67838
67839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
67840   int jresult ;
67841   int result;
67842
67843   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
67844   jresult = (int)result;
67845   return jresult;
67846 }
67847
67848
67849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
67850   int jresult ;
67851   int result;
67852
67853   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
67854   jresult = (int)result;
67855   return jresult;
67856 }
67857
67858
67859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
67860   int jresult ;
67861   int result;
67862
67863   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
67864   jresult = (int)result;
67865   return jresult;
67866 }
67867
67868
67869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
67870   int jresult ;
67871   int result;
67872
67873   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
67874   jresult = (int)result;
67875   return jresult;
67876 }
67877
67878
67879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
67880   int jresult ;
67881   int result;
67882
67883   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
67884   jresult = (int)result;
67885   return jresult;
67886 }
67887
67888
67889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
67890   int jresult ;
67891   int result;
67892
67893   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
67894   jresult = (int)result;
67895   return jresult;
67896 }
67897
67898
67899 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
67900   int jresult ;
67901   int result;
67902
67903   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
67904   jresult = (int)result;
67905   return jresult;
67906 }
67907
67908
67909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
67910   int jresult ;
67911   int result;
67912
67913   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
67914   jresult = (int)result;
67915   return jresult;
67916 }
67917
67918
67919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
67920   void * jresult ;
67921   Dali::Toolkit::Scrollable::Property *result = 0 ;
67922
67923   {
67924     try {
67925       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
67926     } catch (std::out_of_range& e) {
67927       {
67928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67929       };
67930     } catch (std::exception& e) {
67931       {
67932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67933       };
67934     } catch (...) {
67935       {
67936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67937       };
67938     }
67939   }
67940   jresult = (void *)result;
67941   return jresult;
67942 }
67943
67944
67945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
67946   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
67947
67948   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
67949   {
67950     try {
67951       delete arg1;
67952     } catch (std::out_of_range& e) {
67953       {
67954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67955       };
67956     } catch (std::exception& e) {
67957       {
67958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67959       };
67960     } catch (...) {
67961       {
67962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67963       };
67964     }
67965   }
67966 }
67967
67968
67969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
67970   void * jresult ;
67971   Dali::Toolkit::Scrollable *result = 0 ;
67972
67973   {
67974     try {
67975       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
67976     } catch (std::out_of_range& e) {
67977       {
67978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67979       };
67980     } catch (std::exception& e) {
67981       {
67982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67983       };
67984     } catch (...) {
67985       {
67986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67987       };
67988     }
67989   }
67990   jresult = (void *)result;
67991   return jresult;
67992 }
67993
67994
67995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
67996   void * jresult ;
67997   Dali::Toolkit::Scrollable *arg1 = 0 ;
67998   Dali::Toolkit::Scrollable *result = 0 ;
67999
68000   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68001   if (!arg1) {
68002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68003     return 0;
68004   }
68005   {
68006     try {
68007       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
68008     } catch (std::out_of_range& e) {
68009       {
68010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68011       };
68012     } catch (std::exception& e) {
68013       {
68014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68015       };
68016     } catch (...) {
68017       {
68018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68019       };
68020     }
68021   }
68022   jresult = (void *)result;
68023   return jresult;
68024 }
68025
68026
68027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
68028   void * jresult ;
68029   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68030   Dali::Toolkit::Scrollable *arg2 = 0 ;
68031   Dali::Toolkit::Scrollable *result = 0 ;
68032
68033   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68034   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
68035   if (!arg2) {
68036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68037     return 0;
68038   }
68039   {
68040     try {
68041       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
68042     } catch (std::out_of_range& e) {
68043       {
68044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68045       };
68046     } catch (std::exception& e) {
68047       {
68048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68049       };
68050     } catch (...) {
68051       {
68052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68053       };
68054     }
68055   }
68056   jresult = (void *)result;
68057   return jresult;
68058 }
68059
68060
68061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
68062   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68063
68064   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68065   {
68066     try {
68067       delete arg1;
68068     } catch (std::out_of_range& e) {
68069       {
68070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68071       };
68072     } catch (std::exception& e) {
68073       {
68074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68075       };
68076     } catch (...) {
68077       {
68078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68079       };
68080     }
68081   }
68082 }
68083
68084
68085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
68086   void * jresult ;
68087   Dali::BaseHandle arg1 ;
68088   Dali::BaseHandle *argp1 ;
68089   Dali::Toolkit::Scrollable result;
68090
68091   argp1 = (Dali::BaseHandle *)jarg1;
68092   if (!argp1) {
68093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68094     return 0;
68095   }
68096   arg1 = *argp1;
68097   {
68098     try {
68099       result = Dali::Toolkit::Scrollable::DownCast(arg1);
68100     } catch (std::out_of_range& e) {
68101       {
68102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68103       };
68104     } catch (std::exception& e) {
68105       {
68106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68107       };
68108     } catch (...) {
68109       {
68110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68111       };
68112     }
68113   }
68114   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
68115   return jresult;
68116 }
68117
68118
68119 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
68120   unsigned int jresult ;
68121   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68122   bool result;
68123
68124   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68125   {
68126     try {
68127       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
68128     } catch (std::out_of_range& e) {
68129       {
68130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68131       };
68132     } catch (std::exception& e) {
68133       {
68134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68135       };
68136     } catch (...) {
68137       {
68138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68139       };
68140     }
68141   }
68142   jresult = result;
68143   return jresult;
68144 }
68145
68146
68147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
68148   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68149   bool arg2 ;
68150
68151   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68152   arg2 = jarg2 ? true : false;
68153   {
68154     try {
68155       (arg1)->SetOvershootEnabled(arg2);
68156     } catch (std::out_of_range& e) {
68157       {
68158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68159       };
68160     } catch (std::exception& e) {
68161       {
68162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68163       };
68164     } catch (...) {
68165       {
68166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68167       };
68168     }
68169   }
68170 }
68171
68172
68173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
68174   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68175   Dali::Vector4 *arg2 = 0 ;
68176
68177   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68178   arg2 = (Dali::Vector4 *)jarg2;
68179   if (!arg2) {
68180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
68181     return ;
68182   }
68183   {
68184     try {
68185       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
68186     } catch (std::out_of_range& e) {
68187       {
68188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68189       };
68190     } catch (std::exception& e) {
68191       {
68192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68193       };
68194     } catch (...) {
68195       {
68196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68197       };
68198     }
68199   }
68200 }
68201
68202
68203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
68204   void * jresult ;
68205   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68206   Dali::Vector4 result;
68207
68208   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68209   {
68210     try {
68211       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
68212     } catch (std::out_of_range& e) {
68213       {
68214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68215       };
68216     } catch (std::exception& e) {
68217       {
68218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68219       };
68220     } catch (...) {
68221       {
68222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68223       };
68224     }
68225   }
68226   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
68227   return jresult;
68228 }
68229
68230
68231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
68232   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68233   float arg2 ;
68234
68235   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68236   arg2 = (float)jarg2;
68237   {
68238     try {
68239       (arg1)->SetOvershootAnimationSpeed(arg2);
68240     } catch (std::out_of_range& e) {
68241       {
68242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68243       };
68244     } catch (std::exception& e) {
68245       {
68246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68247       };
68248     } catch (...) {
68249       {
68250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68251       };
68252     }
68253   }
68254 }
68255
68256
68257 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
68258   float jresult ;
68259   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68260   float result;
68261
68262   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68263   {
68264     try {
68265       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
68266     } catch (std::out_of_range& e) {
68267       {
68268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68269       };
68270     } catch (std::exception& e) {
68271       {
68272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68273       };
68274     } catch (...) {
68275       {
68276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68277       };
68278     }
68279   }
68280   jresult = result;
68281   return jresult;
68282 }
68283
68284
68285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
68286   void * jresult ;
68287   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68288   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
68289
68290   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68291   {
68292     try {
68293       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
68294     } catch (std::out_of_range& e) {
68295       {
68296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68297       };
68298     } catch (std::exception& e) {
68299       {
68300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68301       };
68302     } catch (...) {
68303       {
68304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68305       };
68306     }
68307   }
68308   jresult = (void *)result;
68309   return jresult;
68310 }
68311
68312
68313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
68314   void * jresult ;
68315   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68316   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
68317
68318   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68319   {
68320     try {
68321       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
68322     } catch (std::out_of_range& e) {
68323       {
68324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68325       };
68326     } catch (std::exception& e) {
68327       {
68328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68329       };
68330     } catch (...) {
68331       {
68332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68333       };
68334     }
68335   }
68336   jresult = (void *)result;
68337   return jresult;
68338 }
68339
68340
68341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
68342   void * jresult ;
68343   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68344   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
68345
68346   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68347   {
68348     try {
68349       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
68350     } catch (std::out_of_range& e) {
68351       {
68352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68353       };
68354     } catch (std::exception& e) {
68355       {
68356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68357       };
68358     } catch (...) {
68359       {
68360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68361       };
68362     }
68363   }
68364   jresult = (void *)result;
68365   return jresult;
68366 }
68367
68368
68369 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
68370   unsigned int jresult ;
68371   Dali::Toolkit::ControlOrientation::Type arg1 ;
68372   bool result;
68373
68374   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
68375   {
68376     try {
68377       result = (bool)Dali::Toolkit::IsVertical(arg1);
68378     } catch (std::out_of_range& e) {
68379       {
68380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68381       };
68382     } catch (std::exception& e) {
68383       {
68384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68385       };
68386     } catch (...) {
68387       {
68388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68389       };
68390     }
68391   }
68392   jresult = result;
68393   return jresult;
68394 }
68395
68396
68397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
68398   unsigned int jresult ;
68399   Dali::Toolkit::ControlOrientation::Type arg1 ;
68400   bool result;
68401
68402   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
68403   {
68404     try {
68405       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
68406     } catch (std::out_of_range& e) {
68407       {
68408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68409       };
68410     } catch (std::exception& e) {
68411       {
68412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68413       };
68414     } catch (...) {
68415       {
68416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68417       };
68418     }
68419   }
68420   jresult = result;
68421   return jresult;
68422 }
68423
68424
68425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
68426   void * jresult ;
68427   unsigned int arg1 ;
68428   unsigned int arg2 ;
68429   Dali::Toolkit::ItemRange *result = 0 ;
68430
68431   arg1 = (unsigned int)jarg1;
68432   arg2 = (unsigned int)jarg2;
68433   {
68434     try {
68435       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
68436     } catch (std::out_of_range& e) {
68437       {
68438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68439       };
68440     } catch (std::exception& e) {
68441       {
68442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68443       };
68444     } catch (...) {
68445       {
68446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68447       };
68448     }
68449   }
68450   jresult = (void *)result;
68451   return jresult;
68452 }
68453
68454
68455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
68456   void * jresult ;
68457   Dali::Toolkit::ItemRange *arg1 = 0 ;
68458   Dali::Toolkit::ItemRange *result = 0 ;
68459
68460   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68461   if (!arg1) {
68462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68463     return 0;
68464   }
68465   {
68466     try {
68467       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
68468     } catch (std::out_of_range& e) {
68469       {
68470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68471       };
68472     } catch (std::exception& e) {
68473       {
68474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68475       };
68476     } catch (...) {
68477       {
68478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68479       };
68480     }
68481   }
68482   jresult = (void *)result;
68483   return jresult;
68484 }
68485
68486
68487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
68488   void * jresult ;
68489   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68490   Dali::Toolkit::ItemRange *arg2 = 0 ;
68491   Dali::Toolkit::ItemRange *result = 0 ;
68492
68493   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68494   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
68495   if (!arg2) {
68496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68497     return 0;
68498   }
68499   {
68500     try {
68501       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
68502     } catch (std::out_of_range& e) {
68503       {
68504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68505       };
68506     } catch (std::exception& e) {
68507       {
68508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68509       };
68510     } catch (...) {
68511       {
68512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68513       };
68514     }
68515   }
68516   jresult = (void *)result;
68517   return jresult;
68518 }
68519
68520
68521 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
68522   unsigned int jresult ;
68523   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68524   unsigned int arg2 ;
68525   bool result;
68526
68527   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68528   arg2 = (unsigned int)jarg2;
68529   {
68530     try {
68531       result = (bool)(arg1)->Within(arg2);
68532     } catch (std::out_of_range& e) {
68533       {
68534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68535       };
68536     } catch (std::exception& e) {
68537       {
68538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68539       };
68540     } catch (...) {
68541       {
68542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68543       };
68544     }
68545   }
68546   jresult = result;
68547   return jresult;
68548 }
68549
68550
68551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
68552   void * jresult ;
68553   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68554   Dali::Toolkit::ItemRange *arg2 = 0 ;
68555   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
68556
68557   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68558   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
68559   if (!arg2) {
68560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68561     return 0;
68562   }
68563   {
68564     try {
68565       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
68566     } catch (std::out_of_range& e) {
68567       {
68568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68569       };
68570     } catch (std::exception& e) {
68571       {
68572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68573       };
68574     } catch (...) {
68575       {
68576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68577       };
68578     }
68579   }
68580   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
68581   return jresult;
68582 }
68583
68584
68585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
68586   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68587   unsigned int arg2 ;
68588
68589   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68590   arg2 = (unsigned int)jarg2;
68591   if (arg1) (arg1)->begin = arg2;
68592 }
68593
68594
68595 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
68596   unsigned int jresult ;
68597   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68598   unsigned int result;
68599
68600   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68601   result = (unsigned int) ((arg1)->begin);
68602   jresult = result;
68603   return jresult;
68604 }
68605
68606
68607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
68608   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68609   unsigned int arg2 ;
68610
68611   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68612   arg2 = (unsigned int)jarg2;
68613   if (arg1) (arg1)->end = arg2;
68614 }
68615
68616
68617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
68618   unsigned int jresult ;
68619   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68620   unsigned int result;
68621
68622   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68623   result = (unsigned int) ((arg1)->end);
68624   jresult = result;
68625   return jresult;
68626 }
68627
68628
68629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
68630   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68631
68632   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68633   {
68634     try {
68635       delete arg1;
68636     } catch (std::out_of_range& e) {
68637       {
68638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68639       };
68640     } catch (std::exception& e) {
68641       {
68642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68643       };
68644     } catch (...) {
68645       {
68646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68647       };
68648     }
68649   }
68650 }
68651
68652
68653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
68654   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68655
68656   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68657   {
68658     try {
68659       delete arg1;
68660     } catch (std::out_of_range& e) {
68661       {
68662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68663       };
68664     } catch (std::exception& e) {
68665       {
68666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68667       };
68668     } catch (...) {
68669       {
68670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68671       };
68672     }
68673   }
68674 }
68675
68676
68677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
68678   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68679   Dali::Toolkit::ControlOrientation::Type arg2 ;
68680
68681   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68682   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
68683   {
68684     try {
68685       (arg1)->SetOrientation(arg2);
68686     } catch (std::out_of_range& e) {
68687       {
68688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68689       };
68690     } catch (std::exception& e) {
68691       {
68692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68693       };
68694     } catch (...) {
68695       {
68696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68697       };
68698     }
68699   }
68700 }
68701
68702
68703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
68704   int jresult ;
68705   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68706   Dali::Toolkit::ControlOrientation::Type result;
68707
68708   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68709   {
68710     try {
68711       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
68712     } catch (std::out_of_range& e) {
68713       {
68714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68715       };
68716     } catch (std::exception& e) {
68717       {
68718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68719       };
68720     } catch (...) {
68721       {
68722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68723       };
68724     }
68725   }
68726   jresult = (int)result;
68727   return jresult;
68728 }
68729
68730
68731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
68732   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68733   Dali::Property::Map *arg2 = 0 ;
68734
68735   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68736   arg2 = (Dali::Property::Map *)jarg2;
68737   if (!arg2) {
68738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
68739     return ;
68740   }
68741   {
68742     try {
68743       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
68744     } catch (std::out_of_range& e) {
68745       {
68746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68747       };
68748     } catch (std::exception& e) {
68749       {
68750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68751       };
68752     } catch (...) {
68753       {
68754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68755       };
68756     }
68757   }
68758 }
68759
68760
68761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
68762   void * jresult ;
68763   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68764   Dali::Property::Map result;
68765
68766   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68767   {
68768     try {
68769       result = (arg1)->GetLayoutProperties();
68770     } catch (std::out_of_range& e) {
68771       {
68772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68773       };
68774     } catch (std::exception& e) {
68775       {
68776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68777       };
68778     } catch (...) {
68779       {
68780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68781       };
68782     }
68783   }
68784   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
68785   return jresult;
68786 }
68787
68788
68789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
68790   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68791   unsigned int arg2 ;
68792   Dali::Vector3 *arg3 = 0 ;
68793   Dali::Vector3 *arg4 = 0 ;
68794
68795   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68796   arg2 = (unsigned int)jarg2;
68797   arg3 = (Dali::Vector3 *)jarg3;
68798   if (!arg3) {
68799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68800     return ;
68801   }
68802   arg4 = (Dali::Vector3 *)jarg4;
68803   if (!arg4) {
68804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
68805     return ;
68806   }
68807   {
68808     try {
68809       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
68810     } catch (std::out_of_range& e) {
68811       {
68812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68813       };
68814     } catch (std::exception& e) {
68815       {
68816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68817       };
68818     } catch (...) {
68819       {
68820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68821       };
68822     }
68823   }
68824 }
68825
68826
68827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
68828   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68829   Dali::Vector3 *arg2 = 0 ;
68830
68831   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68832   arg2 = (Dali::Vector3 *)jarg2;
68833   if (!arg2) {
68834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68835     return ;
68836   }
68837   {
68838     try {
68839       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
68840     } catch (std::out_of_range& e) {
68841       {
68842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68843       };
68844     } catch (std::exception& e) {
68845       {
68846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68847       };
68848     } catch (...) {
68849       {
68850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68851       };
68852     }
68853   }
68854 }
68855
68856
68857 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
68858   float jresult ;
68859   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68860   unsigned int arg2 ;
68861   Dali::Vector3 arg3 ;
68862   Dali::Vector3 *argp3 ;
68863   float result;
68864
68865   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68866   arg2 = (unsigned int)jarg2;
68867   argp3 = (Dali::Vector3 *)jarg3;
68868   if (!argp3) {
68869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
68870     return 0;
68871   }
68872   arg3 = *argp3;
68873   {
68874     try {
68875       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
68876     } catch (std::out_of_range& e) {
68877       {
68878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68879       };
68880     } catch (std::exception& e) {
68881       {
68882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68883       };
68884     } catch (...) {
68885       {
68886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68887       };
68888     }
68889   }
68890   jresult = result;
68891   return jresult;
68892 }
68893
68894
68895 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
68896   float jresult ;
68897   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68898   float arg2 ;
68899   float result;
68900
68901   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68902   arg2 = (float)jarg2;
68903   {
68904     try {
68905       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
68906     } catch (std::out_of_range& e) {
68907       {
68908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68909       };
68910     } catch (std::exception& e) {
68911       {
68912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68913       };
68914     } catch (...) {
68915       {
68916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68917       };
68918     }
68919   }
68920   jresult = result;
68921   return jresult;
68922 }
68923
68924
68925 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
68926   float jresult ;
68927   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68928   unsigned int arg2 ;
68929   float result;
68930
68931   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68932   arg2 = (unsigned int)jarg2;
68933   {
68934     try {
68935       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
68936     } catch (std::out_of_range& e) {
68937       {
68938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68939       };
68940     } catch (std::exception& e) {
68941       {
68942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68943       };
68944     } catch (...) {
68945       {
68946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68947       };
68948     }
68949   }
68950   jresult = result;
68951   return jresult;
68952 }
68953
68954
68955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
68956   void * jresult ;
68957   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68958   float arg2 ;
68959   Dali::Vector3 arg3 ;
68960   Dali::Vector3 *argp3 ;
68961   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
68962
68963   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68964   arg2 = (float)jarg2;
68965   argp3 = (Dali::Vector3 *)jarg3;
68966   if (!argp3) {
68967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
68968     return 0;
68969   }
68970   arg3 = *argp3;
68971   {
68972     try {
68973       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
68974     } catch (std::out_of_range& e) {
68975       {
68976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68977       };
68978     } catch (std::exception& e) {
68979       {
68980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68981       };
68982     } catch (...) {
68983       {
68984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68985       };
68986     }
68987   }
68988   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
68989   return jresult;
68990 }
68991
68992
68993 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
68994   float jresult ;
68995   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68996   int arg2 ;
68997   float arg3 ;
68998   Dali::Vector3 *arg4 = 0 ;
68999   float result;
69000
69001   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69002   arg2 = (int)jarg2;
69003   arg3 = (float)jarg3;
69004   arg4 = (Dali::Vector3 *)jarg4;
69005   if (!arg4) {
69006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69007     return 0;
69008   }
69009   {
69010     try {
69011       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
69012     } catch (std::out_of_range& e) {
69013       {
69014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69015       };
69016     } catch (std::exception& e) {
69017       {
69018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69019       };
69020     } catch (...) {
69021       {
69022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69023       };
69024     }
69025   }
69026   jresult = result;
69027   return jresult;
69028 }
69029
69030
69031 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
69032   unsigned int jresult ;
69033   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69034   Dali::Vector3 arg2 ;
69035   Dali::Vector3 *argp2 ;
69036   unsigned int result;
69037
69038   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69039   argp2 = (Dali::Vector3 *)jarg2;
69040   if (!argp2) {
69041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69042     return 0;
69043   }
69044   arg2 = *argp2;
69045   {
69046     try {
69047       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
69048     } catch (std::out_of_range& e) {
69049       {
69050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69051       };
69052     } catch (std::exception& e) {
69053       {
69054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69055       };
69056     } catch (...) {
69057       {
69058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69059       };
69060     }
69061   }
69062   jresult = result;
69063   return jresult;
69064 }
69065
69066
69067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69068   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69069   unsigned int arg2 ;
69070   Dali::Vector3 *arg3 = 0 ;
69071   Dali::Vector3 *arg4 = 0 ;
69072
69073   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69074   arg2 = (unsigned int)jarg2;
69075   arg3 = (Dali::Vector3 *)jarg3;
69076   if (!arg3) {
69077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69078     return ;
69079   }
69080   arg4 = (Dali::Vector3 *)jarg4;
69081   if (!arg4) {
69082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69083     return ;
69084   }
69085   {
69086     try {
69087       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69088     } catch (std::out_of_range& e) {
69089       {
69090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69091       };
69092     } catch (std::exception& e) {
69093       {
69094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69095       };
69096     } catch (...) {
69097       {
69098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69099       };
69100     }
69101   }
69102 }
69103
69104
69105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
69106   void * jresult ;
69107   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69108   Dali::Degree result;
69109
69110   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69111   {
69112     try {
69113       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
69114     } catch (std::out_of_range& e) {
69115       {
69116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69117       };
69118     } catch (std::exception& e) {
69119       {
69120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69121       };
69122     } catch (...) {
69123       {
69124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69125       };
69126     }
69127   }
69128   jresult = new Dali::Degree((const Dali::Degree &)result);
69129   return jresult;
69130 }
69131
69132
69133 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
69134   float jresult ;
69135   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69136   float result;
69137
69138   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69139   {
69140     try {
69141       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
69142     } catch (std::out_of_range& e) {
69143       {
69144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69145       };
69146     } catch (std::exception& e) {
69147       {
69148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69149       };
69150     } catch (...) {
69151       {
69152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69153       };
69154     }
69155   }
69156   jresult = result;
69157   return jresult;
69158 }
69159
69160
69161 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
69162   float jresult ;
69163   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69164   float result;
69165
69166   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69167   {
69168     try {
69169       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
69170     } catch (std::out_of_range& e) {
69171       {
69172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69173       };
69174     } catch (std::exception& e) {
69175       {
69176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69177       };
69178     } catch (...) {
69179       {
69180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69181       };
69182     }
69183   }
69184   jresult = result;
69185   return jresult;
69186 }
69187
69188
69189 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
69190   float jresult ;
69191   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69192   float result;
69193
69194   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69195   {
69196     try {
69197       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
69198     } catch (std::out_of_range& e) {
69199       {
69200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69201       };
69202     } catch (std::exception& e) {
69203       {
69204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69205       };
69206     } catch (...) {
69207       {
69208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69209       };
69210     }
69211   }
69212   jresult = result;
69213   return jresult;
69214 }
69215
69216
69217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
69218   int jresult ;
69219   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69220   int arg2 ;
69221   int arg3 ;
69222   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
69223   bool arg5 ;
69224   int result;
69225
69226   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69227   arg2 = (int)jarg2;
69228   arg3 = (int)jarg3;
69229   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
69230   arg5 = jarg5 ? true : false;
69231   {
69232     try {
69233       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
69234     } catch (std::out_of_range& e) {
69235       {
69236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69237       };
69238     } catch (std::exception& e) {
69239       {
69240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69241       };
69242     } catch (...) {
69243       {
69244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69245       };
69246     }
69247   }
69248   jresult = result;
69249   return jresult;
69250 }
69251
69252
69253 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
69254   float jresult ;
69255   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69256   float result;
69257
69258   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69259   {
69260     try {
69261       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
69262     } catch (std::out_of_range& e) {
69263       {
69264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69265       };
69266     } catch (std::exception& e) {
69267       {
69268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69269       };
69270     } catch (...) {
69271       {
69272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69273       };
69274     }
69275   }
69276   jresult = result;
69277   return jresult;
69278 }
69279
69280
69281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
69282   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69283   Dali::Actor *arg2 = 0 ;
69284   int arg3 ;
69285   Dali::Vector3 *arg4 = 0 ;
69286   Dali::Actor *arg5 = 0 ;
69287
69288   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69289   arg2 = (Dali::Actor *)jarg2;
69290   if (!arg2) {
69291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
69292     return ;
69293   }
69294   arg3 = (int)jarg3;
69295   arg4 = (Dali::Vector3 *)jarg4;
69296   if (!arg4) {
69297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69298     return ;
69299   }
69300   arg5 = (Dali::Actor *)jarg5;
69301   if (!arg5) {
69302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
69303     return ;
69304   }
69305   {
69306     try {
69307       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
69308     } catch (std::out_of_range& e) {
69309       {
69310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69311       };
69312     } catch (std::exception& e) {
69313       {
69314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69315       };
69316     } catch (...) {
69317       {
69318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69319       };
69320     }
69321   }
69322 }
69323
69324
69325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
69326   void * jresult ;
69327   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69328   int arg2 ;
69329   float arg3 ;
69330   Dali::Vector3 *arg4 = 0 ;
69331   Dali::Vector3 result;
69332
69333   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69334   arg2 = (int)jarg2;
69335   arg3 = (float)jarg3;
69336   arg4 = (Dali::Vector3 *)jarg4;
69337   if (!arg4) {
69338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69339     return 0;
69340   }
69341   {
69342     try {
69343       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
69344     } catch (std::out_of_range& e) {
69345       {
69346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69347       };
69348     } catch (std::exception& e) {
69349       {
69350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69351       };
69352     } catch (...) {
69353       {
69354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69355       };
69356     }
69357   }
69358   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
69359   return jresult;
69360 }
69361
69362
69363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
69364   void * jresult ;
69365   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
69366   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
69367
69368   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
69369   {
69370     try {
69371       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
69372     } catch (std::out_of_range& e) {
69373       {
69374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69375       };
69376     } catch (std::exception& e) {
69377       {
69378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69379       };
69380     } catch (...) {
69381       {
69382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69383       };
69384     }
69385   }
69386   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
69387   return jresult;
69388 }
69389
69390
69391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
69392   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69393
69394   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69395   {
69396     try {
69397       delete arg1;
69398     } catch (std::out_of_range& e) {
69399       {
69400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69401       };
69402     } catch (std::exception& e) {
69403       {
69404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69405       };
69406     } catch (...) {
69407       {
69408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69409       };
69410     }
69411   }
69412 }
69413
69414
69415 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
69416   unsigned int jresult ;
69417   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69418   unsigned int result;
69419
69420   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69421   {
69422     try {
69423       result = (unsigned int)(arg1)->GetNumberOfItems();
69424     } catch (std::out_of_range& e) {
69425       {
69426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69427       };
69428     } catch (std::exception& e) {
69429       {
69430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69431       };
69432     } catch (...) {
69433       {
69434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69435       };
69436     }
69437   }
69438   jresult = result;
69439   return jresult;
69440 }
69441
69442
69443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
69444   void * jresult ;
69445   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69446   unsigned int arg2 ;
69447   Dali::Actor result;
69448
69449   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69450   arg2 = (unsigned int)jarg2;
69451   {
69452     try {
69453       result = (arg1)->NewItem(arg2);
69454     } catch (std::out_of_range& e) {
69455       {
69456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69457       };
69458     } catch (std::exception& e) {
69459       {
69460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69461       };
69462     } catch (...) {
69463       {
69464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69465       };
69466     }
69467   }
69468   jresult = new Dali::Actor((const Dali::Actor &)result);
69469   return jresult;
69470 }
69471
69472
69473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
69474   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69475   unsigned int arg2 ;
69476   Dali::Actor arg3 ;
69477   Dali::Actor *argp3 ;
69478
69479   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69480   arg2 = (unsigned int)jarg2;
69481   argp3 = (Dali::Actor *)jarg3;
69482   if (!argp3) {
69483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69484     return ;
69485   }
69486   arg3 = *argp3;
69487   {
69488     try {
69489       (arg1)->ItemReleased(arg2,arg3);
69490     } catch (std::out_of_range& e) {
69491       {
69492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69493       };
69494     } catch (std::exception& e) {
69495       {
69496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69497       };
69498     } catch (...) {
69499       {
69500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69501       };
69502     }
69503   }
69504 }
69505
69506
69507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
69508   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69509   unsigned int arg2 ;
69510   Dali::Actor arg3 ;
69511   Dali::Actor *argp3 ;
69512
69513   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69514   arg2 = (unsigned int)jarg2;
69515   argp3 = (Dali::Actor *)jarg3;
69516   if (!argp3) {
69517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69518     return ;
69519   }
69520   arg3 = *argp3;
69521   {
69522     try {
69523       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
69524     } catch (std::out_of_range& e) {
69525       {
69526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69527       };
69528     } catch (std::exception& e) {
69529       {
69530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69531       };
69532     } catch (...) {
69533       {
69534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69535       };
69536     }
69537   }
69538 }
69539
69540
69541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
69542   void * jresult ;
69543   Dali::Toolkit::ItemFactory *result = 0 ;
69544
69545   {
69546     try {
69547       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
69548     } catch (std::out_of_range& e) {
69549       {
69550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69551       };
69552     } catch (std::exception& e) {
69553       {
69554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69555       };
69556     } catch (...) {
69557       {
69558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69559       };
69560     }
69561   }
69562   jresult = (void *)result;
69563   return jresult;
69564 }
69565
69566
69567 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) {
69568   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
69569   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
69570   if (director) {
69571     director->swig_connect_director(callback0, callback1, callback2);
69572   }
69573 }
69574
69575
69576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
69577   int jresult ;
69578   int result;
69579
69580   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
69581   jresult = (int)result;
69582   return jresult;
69583 }
69584
69585
69586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
69587   int jresult ;
69588   int result;
69589
69590   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
69591   jresult = (int)result;
69592   return jresult;
69593 }
69594
69595
69596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
69597   int jresult ;
69598   int result;
69599
69600   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
69601   jresult = (int)result;
69602   return jresult;
69603 }
69604
69605
69606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
69607   int jresult ;
69608   int result;
69609
69610   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
69611   jresult = (int)result;
69612   return jresult;
69613 }
69614
69615
69616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
69617   int jresult ;
69618   int result;
69619
69620   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
69621   jresult = (int)result;
69622   return jresult;
69623 }
69624
69625
69626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
69627   int jresult ;
69628   int result;
69629
69630   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
69631   jresult = (int)result;
69632   return jresult;
69633 }
69634
69635
69636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
69637   int jresult ;
69638   int result;
69639
69640   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
69641   jresult = (int)result;
69642   return jresult;
69643 }
69644
69645
69646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
69647   int jresult ;
69648   int result;
69649
69650   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
69651   jresult = (int)result;
69652   return jresult;
69653 }
69654
69655
69656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
69657   int jresult ;
69658   int result;
69659
69660   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
69661   jresult = (int)result;
69662   return jresult;
69663 }
69664
69665
69666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
69667   int jresult ;
69668   int result;
69669
69670   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
69671   jresult = (int)result;
69672   return jresult;
69673 }
69674
69675
69676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
69677   int jresult ;
69678   int result;
69679
69680   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
69681   jresult = (int)result;
69682   return jresult;
69683 }
69684
69685
69686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
69687   void * jresult ;
69688   Dali::Toolkit::ItemView::Property *result = 0 ;
69689
69690   {
69691     try {
69692       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
69693     } catch (std::out_of_range& e) {
69694       {
69695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69696       };
69697     } catch (std::exception& e) {
69698       {
69699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69700       };
69701     } catch (...) {
69702       {
69703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69704       };
69705     }
69706   }
69707   jresult = (void *)result;
69708   return jresult;
69709 }
69710
69711
69712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
69713   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
69714
69715   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
69716   {
69717     try {
69718       delete arg1;
69719     } catch (std::out_of_range& e) {
69720       {
69721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69722       };
69723     } catch (std::exception& e) {
69724       {
69725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69726       };
69727     } catch (...) {
69728       {
69729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69730       };
69731     }
69732   }
69733 }
69734
69735
69736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
69737   void * jresult ;
69738   Dali::Toolkit::ItemView *result = 0 ;
69739
69740   {
69741     try {
69742       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
69743     } catch (std::out_of_range& e) {
69744       {
69745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69746       };
69747     } catch (std::exception& e) {
69748       {
69749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69750       };
69751     } catch (...) {
69752       {
69753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69754       };
69755     }
69756   }
69757   jresult = (void *)result;
69758   return jresult;
69759 }
69760
69761
69762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
69763   void * jresult ;
69764   Dali::Toolkit::ItemView *arg1 = 0 ;
69765   Dali::Toolkit::ItemView *result = 0 ;
69766
69767   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69768   if (!arg1) {
69769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
69770     return 0;
69771   }
69772   {
69773     try {
69774       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
69775     } catch (std::out_of_range& e) {
69776       {
69777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69778       };
69779     } catch (std::exception& e) {
69780       {
69781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69782       };
69783     } catch (...) {
69784       {
69785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69786       };
69787     }
69788   }
69789   jresult = (void *)result;
69790   return jresult;
69791 }
69792
69793
69794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
69795   void * jresult ;
69796   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69797   Dali::Toolkit::ItemView *arg2 = 0 ;
69798   Dali::Toolkit::ItemView *result = 0 ;
69799
69800   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69801   arg2 = (Dali::Toolkit::ItemView *)jarg2;
69802   if (!arg2) {
69803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
69804     return 0;
69805   }
69806   {
69807     try {
69808       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
69809     } catch (std::out_of_range& e) {
69810       {
69811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69812       };
69813     } catch (std::exception& e) {
69814       {
69815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69816       };
69817     } catch (...) {
69818       {
69819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69820       };
69821     }
69822   }
69823   jresult = (void *)result;
69824   return jresult;
69825 }
69826
69827
69828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
69829   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69830
69831   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69832   {
69833     try {
69834       delete arg1;
69835     } catch (std::out_of_range& e) {
69836       {
69837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69838       };
69839     } catch (std::exception& e) {
69840       {
69841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69842       };
69843     } catch (...) {
69844       {
69845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69846       };
69847     }
69848   }
69849 }
69850
69851
69852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
69853   void * jresult ;
69854   Dali::Toolkit::ItemFactory *arg1 = 0 ;
69855   Dali::Toolkit::ItemView result;
69856
69857   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69858   if (!arg1) {
69859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
69860     return 0;
69861   }
69862   {
69863     try {
69864       result = Dali::Toolkit::ItemView::New(*arg1);
69865     } catch (std::out_of_range& e) {
69866       {
69867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69868       };
69869     } catch (std::exception& e) {
69870       {
69871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69872       };
69873     } catch (...) {
69874       {
69875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69876       };
69877     }
69878   }
69879   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
69880   return jresult;
69881 }
69882
69883
69884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
69885   void * jresult ;
69886   Dali::BaseHandle arg1 ;
69887   Dali::BaseHandle *argp1 ;
69888   Dali::Toolkit::ItemView result;
69889
69890   argp1 = (Dali::BaseHandle *)jarg1;
69891   if (!argp1) {
69892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69893     return 0;
69894   }
69895   arg1 = *argp1;
69896   {
69897     try {
69898       result = Dali::Toolkit::ItemView::DownCast(arg1);
69899     } catch (std::out_of_range& e) {
69900       {
69901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69902       };
69903     } catch (std::exception& e) {
69904       {
69905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69906       };
69907     } catch (...) {
69908       {
69909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69910       };
69911     }
69912   }
69913   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
69914   return jresult;
69915 }
69916
69917
69918 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
69919   unsigned int jresult ;
69920   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69921   unsigned int result;
69922
69923   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69924   {
69925     try {
69926       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
69927     } catch (std::out_of_range& e) {
69928       {
69929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69930       };
69931     } catch (std::exception& e) {
69932       {
69933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69934       };
69935     } catch (...) {
69936       {
69937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69938       };
69939     }
69940   }
69941   jresult = result;
69942   return jresult;
69943 }
69944
69945
69946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
69947   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69948   Dali::Toolkit::ItemLayout *arg2 = 0 ;
69949
69950   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69951   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
69952   if (!arg2) {
69953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
69954     return ;
69955   }
69956   {
69957     try {
69958       (arg1)->AddLayout(*arg2);
69959     } catch (std::out_of_range& e) {
69960       {
69961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69962       };
69963     } catch (std::exception& e) {
69964       {
69965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69966       };
69967     } catch (...) {
69968       {
69969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69970       };
69971     }
69972   }
69973 }
69974
69975
69976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
69977   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69978   unsigned int arg2 ;
69979
69980   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69981   arg2 = (unsigned int)jarg2;
69982   {
69983     try {
69984       (arg1)->RemoveLayout(arg2);
69985     } catch (std::out_of_range& e) {
69986       {
69987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69988       };
69989     } catch (std::exception& e) {
69990       {
69991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69992       };
69993     } catch (...) {
69994       {
69995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69996       };
69997     }
69998   }
69999 }
70000
70001
70002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
70003   void * jresult ;
70004   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70005   unsigned int arg2 ;
70006   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70007
70008   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70009   arg2 = (unsigned int)jarg2;
70010   {
70011     try {
70012       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
70013     } catch (std::out_of_range& e) {
70014       {
70015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70016       };
70017     } catch (std::exception& e) {
70018       {
70019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70020       };
70021     } catch (...) {
70022       {
70023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70024       };
70025     }
70026   }
70027   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70028   return jresult;
70029 }
70030
70031
70032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
70033   void * jresult ;
70034   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70035   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70036
70037   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70038   {
70039     try {
70040       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
70041     } catch (std::out_of_range& e) {
70042       {
70043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70044       };
70045     } catch (std::exception& e) {
70046       {
70047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70048       };
70049     } catch (...) {
70050       {
70051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70052       };
70053     }
70054   }
70055   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70056   return jresult;
70057 }
70058
70059
70060 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
70061   float jresult ;
70062   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70063   Dali::Toolkit::ItemId arg2 ;
70064   float result;
70065
70066   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70067   arg2 = (Dali::Toolkit::ItemId)jarg2;
70068   {
70069     try {
70070       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
70071     } catch (std::out_of_range& e) {
70072       {
70073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70074       };
70075     } catch (std::exception& e) {
70076       {
70077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70078       };
70079     } catch (...) {
70080       {
70081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70082       };
70083     }
70084   }
70085   jresult = result;
70086   return jresult;
70087 }
70088
70089
70090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
70091   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70092   unsigned int arg2 ;
70093   Dali::Vector3 arg3 ;
70094   float arg4 ;
70095   Dali::Vector3 *argp3 ;
70096
70097   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70098   arg2 = (unsigned int)jarg2;
70099   argp3 = (Dali::Vector3 *)jarg3;
70100   if (!argp3) {
70101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
70102     return ;
70103   }
70104   arg3 = *argp3;
70105   arg4 = (float)jarg4;
70106   {
70107     try {
70108       (arg1)->ActivateLayout(arg2,arg3,arg4);
70109     } catch (std::out_of_range& e) {
70110       {
70111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70112       };
70113     } catch (std::exception& e) {
70114       {
70115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70116       };
70117     } catch (...) {
70118       {
70119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70120       };
70121     }
70122   }
70123 }
70124
70125
70126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
70127   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70128
70129   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70130   {
70131     try {
70132       (arg1)->DeactivateCurrentLayout();
70133     } catch (std::out_of_range& e) {
70134       {
70135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70136       };
70137     } catch (std::exception& e) {
70138       {
70139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70140       };
70141     } catch (...) {
70142       {
70143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70144       };
70145     }
70146   }
70147 }
70148
70149
70150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
70151   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70152   float arg2 ;
70153
70154   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70155   arg2 = (float)jarg2;
70156   {
70157     try {
70158       (arg1)->SetMinimumSwipeSpeed(arg2);
70159     } catch (std::out_of_range& e) {
70160       {
70161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70162       };
70163     } catch (std::exception& e) {
70164       {
70165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70166       };
70167     } catch (...) {
70168       {
70169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70170       };
70171     }
70172   }
70173 }
70174
70175
70176 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
70177   float jresult ;
70178   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70179   float result;
70180
70181   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70182   {
70183     try {
70184       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
70185     } catch (std::out_of_range& e) {
70186       {
70187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70188       };
70189     } catch (std::exception& e) {
70190       {
70191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70192       };
70193     } catch (...) {
70194       {
70195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70196       };
70197     }
70198   }
70199   jresult = result;
70200   return jresult;
70201 }
70202
70203
70204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
70205   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70206   float arg2 ;
70207
70208   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70209   arg2 = (float)jarg2;
70210   {
70211     try {
70212       (arg1)->SetMinimumSwipeDistance(arg2);
70213     } catch (std::out_of_range& e) {
70214       {
70215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70216       };
70217     } catch (std::exception& e) {
70218       {
70219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70220       };
70221     } catch (...) {
70222       {
70223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70224       };
70225     }
70226   }
70227 }
70228
70229
70230 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
70231   float jresult ;
70232   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70233   float result;
70234
70235   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70236   {
70237     try {
70238       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
70239     } catch (std::out_of_range& e) {
70240       {
70241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70242       };
70243     } catch (std::exception& e) {
70244       {
70245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70246       };
70247     } catch (...) {
70248       {
70249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70250       };
70251     }
70252   }
70253   jresult = result;
70254   return jresult;
70255 }
70256
70257
70258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
70259   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70260   float arg2 ;
70261
70262   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70263   arg2 = (float)jarg2;
70264   {
70265     try {
70266       (arg1)->SetWheelScrollDistanceStep(arg2);
70267     } catch (std::out_of_range& e) {
70268       {
70269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70270       };
70271     } catch (std::exception& e) {
70272       {
70273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70274       };
70275     } catch (...) {
70276       {
70277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70278       };
70279     }
70280   }
70281 }
70282
70283
70284 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
70285   float jresult ;
70286   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70287   float result;
70288
70289   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70290   {
70291     try {
70292       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
70293     } catch (std::out_of_range& e) {
70294       {
70295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70296       };
70297     } catch (std::exception& e) {
70298       {
70299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70300       };
70301     } catch (...) {
70302       {
70303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70304       };
70305     }
70306   }
70307   jresult = result;
70308   return jresult;
70309 }
70310
70311
70312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
70313   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70314   bool arg2 ;
70315
70316   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70317   arg2 = jarg2 ? true : false;
70318   {
70319     try {
70320       (arg1)->SetAnchoring(arg2);
70321     } catch (std::out_of_range& e) {
70322       {
70323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70324       };
70325     } catch (std::exception& e) {
70326       {
70327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70328       };
70329     } catch (...) {
70330       {
70331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70332       };
70333     }
70334   }
70335 }
70336
70337
70338 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
70339   unsigned int jresult ;
70340   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70341   bool result;
70342
70343   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70344   {
70345     try {
70346       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
70347     } catch (std::out_of_range& e) {
70348       {
70349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70350       };
70351     } catch (std::exception& e) {
70352       {
70353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70354       };
70355     } catch (...) {
70356       {
70357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70358       };
70359     }
70360   }
70361   jresult = result;
70362   return jresult;
70363 }
70364
70365
70366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
70367   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70368   float arg2 ;
70369
70370   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70371   arg2 = (float)jarg2;
70372   {
70373     try {
70374       (arg1)->SetAnchoringDuration(arg2);
70375     } catch (std::out_of_range& e) {
70376       {
70377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70378       };
70379     } catch (std::exception& e) {
70380       {
70381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70382       };
70383     } catch (...) {
70384       {
70385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70386       };
70387     }
70388   }
70389 }
70390
70391
70392 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
70393   float jresult ;
70394   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70395   float result;
70396
70397   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70398   {
70399     try {
70400       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
70401     } catch (std::out_of_range& e) {
70402       {
70403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70404       };
70405     } catch (std::exception& e) {
70406       {
70407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70408       };
70409     } catch (...) {
70410       {
70411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70412       };
70413     }
70414   }
70415   jresult = result;
70416   return jresult;
70417 }
70418
70419
70420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
70421   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70422   Dali::Toolkit::ItemId arg2 ;
70423   float arg3 ;
70424
70425   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70426   arg2 = (Dali::Toolkit::ItemId)jarg2;
70427   arg3 = (float)jarg3;
70428   {
70429     try {
70430       (arg1)->ScrollToItem(arg2,arg3);
70431     } catch (std::out_of_range& e) {
70432       {
70433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70434       };
70435     } catch (std::exception& e) {
70436       {
70437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70438       };
70439     } catch (...) {
70440       {
70441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70442       };
70443     }
70444   }
70445 }
70446
70447
70448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
70449   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70450   float arg2 ;
70451
70452   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70453   arg2 = (float)jarg2;
70454   {
70455     try {
70456       (arg1)->SetRefreshInterval(arg2);
70457     } catch (std::out_of_range& e) {
70458       {
70459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70460       };
70461     } catch (std::exception& e) {
70462       {
70463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70464       };
70465     } catch (...) {
70466       {
70467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70468       };
70469     }
70470   }
70471 }
70472
70473
70474 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
70475   float jresult ;
70476   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70477   float result;
70478
70479   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70480   {
70481     try {
70482       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
70483     } catch (std::out_of_range& e) {
70484       {
70485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70486       };
70487     } catch (std::exception& e) {
70488       {
70489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70490       };
70491     } catch (...) {
70492       {
70493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70494       };
70495     }
70496   }
70497   jresult = result;
70498   return jresult;
70499 }
70500
70501
70502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
70503   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70504
70505   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70506   {
70507     try {
70508       (arg1)->Refresh();
70509     } catch (std::out_of_range& e) {
70510       {
70511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70512       };
70513     } catch (std::exception& e) {
70514       {
70515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70516       };
70517     } catch (...) {
70518       {
70519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70520       };
70521     }
70522   }
70523 }
70524
70525
70526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
70527   void * jresult ;
70528   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70529   Dali::Toolkit::ItemId arg2 ;
70530   Dali::Actor result;
70531
70532   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70533   arg2 = (Dali::Toolkit::ItemId)jarg2;
70534   {
70535     try {
70536       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
70537     } catch (std::out_of_range& e) {
70538       {
70539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70540       };
70541     } catch (std::exception& e) {
70542       {
70543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70544       };
70545     } catch (...) {
70546       {
70547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70548       };
70549     }
70550   }
70551   jresult = new Dali::Actor((const Dali::Actor &)result);
70552   return jresult;
70553 }
70554
70555
70556 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
70557   unsigned int jresult ;
70558   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70559   Dali::Actor arg2 ;
70560   Dali::Actor *argp2 ;
70561   Dali::Toolkit::ItemId result;
70562
70563   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70564   argp2 = (Dali::Actor *)jarg2;
70565   if (!argp2) {
70566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70567     return 0;
70568   }
70569   arg2 = *argp2;
70570   {
70571     try {
70572       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
70573     } catch (std::out_of_range& e) {
70574       {
70575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70576       };
70577     } catch (std::exception& e) {
70578       {
70579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70580       };
70581     } catch (...) {
70582       {
70583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70584       };
70585     }
70586   }
70587   jresult = result;
70588   return jresult;
70589 }
70590
70591
70592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
70593   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70594   Dali::Toolkit::Item arg2 ;
70595   float arg3 ;
70596   Dali::Toolkit::Item *argp2 ;
70597
70598   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70599   argp2 = (Dali::Toolkit::Item *)jarg2;
70600   if (!argp2) {
70601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
70602     return ;
70603   }
70604   arg2 = *argp2;
70605   arg3 = (float)jarg3;
70606   {
70607     try {
70608       (arg1)->InsertItem(arg2,arg3);
70609     } catch (std::out_of_range& e) {
70610       {
70611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70612       };
70613     } catch (std::exception& e) {
70614       {
70615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70616       };
70617     } catch (...) {
70618       {
70619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70620       };
70621     }
70622   }
70623 }
70624
70625
70626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
70627   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70628   Dali::Toolkit::ItemContainer *arg2 = 0 ;
70629   float arg3 ;
70630
70631   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70632   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
70633   if (!arg2) {
70634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
70635     return ;
70636   }
70637   arg3 = (float)jarg3;
70638   {
70639     try {
70640       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
70641     } catch (std::out_of_range& e) {
70642       {
70643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70644       };
70645     } catch (std::exception& e) {
70646       {
70647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70648       };
70649     } catch (...) {
70650       {
70651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70652       };
70653     }
70654   }
70655 }
70656
70657
70658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
70659   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70660   Dali::Toolkit::ItemId arg2 ;
70661   float arg3 ;
70662
70663   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70664   arg2 = (Dali::Toolkit::ItemId)jarg2;
70665   arg3 = (float)jarg3;
70666   {
70667     try {
70668       (arg1)->RemoveItem(arg2,arg3);
70669     } catch (std::out_of_range& e) {
70670       {
70671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70672       };
70673     } catch (std::exception& e) {
70674       {
70675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70676       };
70677     } catch (...) {
70678       {
70679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70680       };
70681     }
70682   }
70683 }
70684
70685
70686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
70687   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70688   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
70689   float arg3 ;
70690
70691   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70692   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
70693   if (!arg2) {
70694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
70695     return ;
70696   }
70697   arg3 = (float)jarg3;
70698   {
70699     try {
70700       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
70701     } catch (std::out_of_range& e) {
70702       {
70703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70704       };
70705     } catch (std::exception& e) {
70706       {
70707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70708       };
70709     } catch (...) {
70710       {
70711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70712       };
70713     }
70714   }
70715 }
70716
70717
70718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
70719   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70720   Dali::Toolkit::Item arg2 ;
70721   float arg3 ;
70722   Dali::Toolkit::Item *argp2 ;
70723
70724   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70725   argp2 = (Dali::Toolkit::Item *)jarg2;
70726   if (!argp2) {
70727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
70728     return ;
70729   }
70730   arg2 = *argp2;
70731   arg3 = (float)jarg3;
70732   {
70733     try {
70734       (arg1)->ReplaceItem(arg2,arg3);
70735     } catch (std::out_of_range& e) {
70736       {
70737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70738       };
70739     } catch (std::exception& e) {
70740       {
70741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70742       };
70743     } catch (...) {
70744       {
70745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70746       };
70747     }
70748   }
70749 }
70750
70751
70752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
70753   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70754   Dali::Toolkit::ItemContainer *arg2 = 0 ;
70755   float arg3 ;
70756
70757   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70758   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
70759   if (!arg2) {
70760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
70761     return ;
70762   }
70763   arg3 = (float)jarg3;
70764   {
70765     try {
70766       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
70767     } catch (std::out_of_range& e) {
70768       {
70769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70770       };
70771     } catch (std::exception& e) {
70772       {
70773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70774       };
70775     } catch (...) {
70776       {
70777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70778       };
70779     }
70780   }
70781 }
70782
70783
70784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
70785   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70786   Dali::Vector3 *arg2 = 0 ;
70787
70788   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70789   arg2 = (Dali::Vector3 *)jarg2;
70790   if (!arg2) {
70791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70792     return ;
70793   }
70794   {
70795     try {
70796       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
70797     } catch (std::out_of_range& e) {
70798       {
70799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70800       };
70801     } catch (std::exception& e) {
70802       {
70803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70804       };
70805     } catch (...) {
70806       {
70807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70808       };
70809     }
70810   }
70811 }
70812
70813
70814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
70815   void * jresult ;
70816   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70817   Dali::Vector3 result;
70818
70819   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70820   {
70821     try {
70822       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
70823     } catch (std::out_of_range& e) {
70824       {
70825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70826       };
70827     } catch (std::exception& e) {
70828       {
70829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70830       };
70831     } catch (...) {
70832       {
70833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70834       };
70835     }
70836   }
70837   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70838   return jresult;
70839 }
70840
70841
70842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
70843   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70844   Dali::Vector3 *arg2 = 0 ;
70845
70846   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70847   arg2 = (Dali::Vector3 *)jarg2;
70848   if (!arg2) {
70849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70850     return ;
70851   }
70852   {
70853     try {
70854       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
70855     } catch (std::out_of_range& e) {
70856       {
70857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70858       };
70859     } catch (std::exception& e) {
70860       {
70861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70862       };
70863     } catch (...) {
70864       {
70865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70866       };
70867     }
70868   }
70869 }
70870
70871
70872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
70873   void * jresult ;
70874   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70875   Dali::Vector3 result;
70876
70877   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70878   {
70879     try {
70880       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
70881     } catch (std::out_of_range& e) {
70882       {
70883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70884       };
70885     } catch (std::exception& e) {
70886       {
70887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70888       };
70889     } catch (...) {
70890       {
70891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70892       };
70893     }
70894   }
70895   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70896   return jresult;
70897 }
70898
70899
70900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
70901   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70902   Dali::Toolkit::ItemRange *arg2 = 0 ;
70903
70904   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70905   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
70906   if (!arg2) {
70907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
70908     return ;
70909   }
70910   {
70911     try {
70912       (arg1)->GetItemsRange(*arg2);
70913     } catch (std::out_of_range& e) {
70914       {
70915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70916       };
70917     } catch (std::exception& e) {
70918       {
70919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70920       };
70921     } catch (...) {
70922       {
70923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70924       };
70925     }
70926   }
70927 }
70928
70929
70930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
70931   void * jresult ;
70932   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70933   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
70934
70935   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70936   {
70937     try {
70938       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
70939     } catch (std::out_of_range& e) {
70940       {
70941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70942       };
70943     } catch (std::exception& e) {
70944       {
70945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70946       };
70947     } catch (...) {
70948       {
70949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70950       };
70951     }
70952   }
70953   jresult = (void *)result;
70954   return jresult;
70955 }
70956
70957
70958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
70959   Dali::Vector3 *arg1 = 0 ;
70960   PropertyInputContainer *arg2 = 0 ;
70961
70962   arg1 = (Dali::Vector3 *)jarg1;
70963   if (!arg1) {
70964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
70965     return ;
70966   }
70967   arg2 = (PropertyInputContainer *)jarg2;
70968   if (!arg2) {
70969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
70970     return ;
70971   }
70972   {
70973     try {
70974       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
70975     } catch (std::out_of_range& e) {
70976       {
70977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70978       };
70979     } catch (std::exception& e) {
70980       {
70981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70982       };
70983     } catch (...) {
70984       {
70985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70986       };
70987     }
70988   }
70989 }
70990
70991
70992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
70993   Dali::Vector3 *arg1 = 0 ;
70994   PropertyInputContainer *arg2 = 0 ;
70995
70996   arg1 = (Dali::Vector3 *)jarg1;
70997   if (!arg1) {
70998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
70999     return ;
71000   }
71001   arg2 = (PropertyInputContainer *)jarg2;
71002   if (!arg2) {
71003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
71004     return ;
71005   }
71006   {
71007     try {
71008       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
71009     } catch (std::out_of_range& e) {
71010       {
71011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71012       };
71013     } catch (std::exception& e) {
71014       {
71015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71016       };
71017     } catch (...) {
71018       {
71019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71020       };
71021     }
71022   }
71023 }
71024
71025
71026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
71027   void * jresult ;
71028   Dali::Toolkit::ScrollViewEffect *result = 0 ;
71029
71030   {
71031     try {
71032       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
71033     } catch (std::out_of_range& e) {
71034       {
71035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71036       };
71037     } catch (std::exception& e) {
71038       {
71039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71040       };
71041     } catch (...) {
71042       {
71043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71044       };
71045     }
71046   }
71047   jresult = (void *)result;
71048   return jresult;
71049 }
71050
71051
71052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
71053   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
71054
71055   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
71056   {
71057     try {
71058       delete arg1;
71059     } catch (std::out_of_range& e) {
71060       {
71061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71062       };
71063     } catch (std::exception& e) {
71064       {
71065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71066       };
71067     } catch (...) {
71068       {
71069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71070       };
71071     }
71072   }
71073 }
71074
71075
71076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
71077   void * jresult ;
71078   Dali::Path arg1 ;
71079   Dali::Vector3 *arg2 = 0 ;
71080   Dali::Property::Index arg3 ;
71081   Dali::Vector3 *arg4 = 0 ;
71082   unsigned int arg5 ;
71083   Dali::Path *argp1 ;
71084   Dali::Toolkit::ScrollViewPagePathEffect result;
71085
71086   argp1 = (Dali::Path *)jarg1;
71087   if (!argp1) {
71088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
71089     return 0;
71090   }
71091   arg1 = *argp1;
71092   arg2 = (Dali::Vector3 *)jarg2;
71093   if (!arg2) {
71094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71095     return 0;
71096   }
71097   arg3 = (Dali::Property::Index)jarg3;
71098   arg4 = (Dali::Vector3 *)jarg4;
71099   if (!arg4) {
71100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71101     return 0;
71102   }
71103   arg5 = (unsigned int)jarg5;
71104   {
71105     try {
71106       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
71107     } catch (std::out_of_range& e) {
71108       {
71109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71110       };
71111     } catch (std::exception& e) {
71112       {
71113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71114       };
71115     } catch (...) {
71116       {
71117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71118       };
71119     }
71120   }
71121   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
71122   return jresult;
71123 }
71124
71125
71126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
71127   void * jresult ;
71128   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
71129
71130   {
71131     try {
71132       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
71133     } catch (std::out_of_range& e) {
71134       {
71135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71136       };
71137     } catch (std::exception& e) {
71138       {
71139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71140       };
71141     } catch (...) {
71142       {
71143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71144       };
71145     }
71146   }
71147   jresult = (void *)result;
71148   return jresult;
71149 }
71150
71151
71152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
71153   void * jresult ;
71154   Dali::BaseHandle arg1 ;
71155   Dali::BaseHandle *argp1 ;
71156   Dali::Toolkit::ScrollViewPagePathEffect result;
71157
71158   argp1 = (Dali::BaseHandle *)jarg1;
71159   if (!argp1) {
71160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71161     return 0;
71162   }
71163   arg1 = *argp1;
71164   {
71165     try {
71166       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
71167     } catch (std::out_of_range& e) {
71168       {
71169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71170       };
71171     } catch (std::exception& e) {
71172       {
71173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71174       };
71175     } catch (...) {
71176       {
71177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71178       };
71179     }
71180   }
71181   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
71182   return jresult;
71183 }
71184
71185
71186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
71187   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
71188   Dali::Actor arg2 ;
71189   unsigned int arg3 ;
71190   Dali::Actor *argp2 ;
71191
71192   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
71193   argp2 = (Dali::Actor *)jarg2;
71194   if (!argp2) {
71195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71196     return ;
71197   }
71198   arg2 = *argp2;
71199   arg3 = (unsigned int)jarg3;
71200   {
71201     try {
71202       (arg1)->ApplyToPage(arg2,arg3);
71203     } catch (std::out_of_range& e) {
71204       {
71205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71206       };
71207     } catch (std::exception& e) {
71208       {
71209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71210       };
71211     } catch (...) {
71212       {
71213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71214       };
71215     }
71216   }
71217 }
71218
71219
71220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
71221   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
71222
71223   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
71224   {
71225     try {
71226       delete arg1;
71227     } catch (std::out_of_range& e) {
71228       {
71229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71230       };
71231     } catch (std::exception& e) {
71232       {
71233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71234       };
71235     } catch (...) {
71236       {
71237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71238       };
71239     }
71240   }
71241 }
71242
71243
71244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
71245   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71246   Dali::Toolkit::ClampState arg2 ;
71247
71248   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71249   arg2 = (Dali::Toolkit::ClampState)jarg2;
71250   if (arg1) (arg1)->x = arg2;
71251 }
71252
71253
71254 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
71255   int jresult ;
71256   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71257   Dali::Toolkit::ClampState result;
71258
71259   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71260   result = (Dali::Toolkit::ClampState) ((arg1)->x);
71261   jresult = (int)result;
71262   return jresult;
71263 }
71264
71265
71266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
71267   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71268   Dali::Toolkit::ClampState arg2 ;
71269
71270   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71271   arg2 = (Dali::Toolkit::ClampState)jarg2;
71272   if (arg1) (arg1)->y = arg2;
71273 }
71274
71275
71276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
71277   int jresult ;
71278   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71279   Dali::Toolkit::ClampState result;
71280
71281   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71282   result = (Dali::Toolkit::ClampState) ((arg1)->y);
71283   jresult = (int)result;
71284   return jresult;
71285 }
71286
71287
71288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
71289   void * jresult ;
71290   Dali::Toolkit::ClampState2D *result = 0 ;
71291
71292   {
71293     try {
71294       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
71295     } catch (std::out_of_range& e) {
71296       {
71297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71298       };
71299     } catch (std::exception& e) {
71300       {
71301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71302       };
71303     } catch (...) {
71304       {
71305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71306       };
71307     }
71308   }
71309   jresult = (void *)result;
71310   return jresult;
71311 }
71312
71313
71314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
71315   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71316
71317   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71318   {
71319     try {
71320       delete arg1;
71321     } catch (std::out_of_range& e) {
71322       {
71323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71324       };
71325     } catch (std::exception& e) {
71326       {
71327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71328       };
71329     } catch (...) {
71330       {
71331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71332       };
71333     }
71334   }
71335 }
71336
71337
71338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
71339   void * jresult ;
71340   float arg1 ;
71341   float arg2 ;
71342   bool arg3 ;
71343   Dali::Toolkit::RulerDomain *result = 0 ;
71344
71345   arg1 = (float)jarg1;
71346   arg2 = (float)jarg2;
71347   arg3 = jarg3 ? true : false;
71348   {
71349     try {
71350       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
71351     } catch (std::out_of_range& e) {
71352       {
71353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71354       };
71355     } catch (std::exception& e) {
71356       {
71357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71358       };
71359     } catch (...) {
71360       {
71361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71362       };
71363     }
71364   }
71365   jresult = (void *)result;
71366   return jresult;
71367 }
71368
71369
71370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
71371   void * jresult ;
71372   float arg1 ;
71373   float arg2 ;
71374   Dali::Toolkit::RulerDomain *result = 0 ;
71375
71376   arg1 = (float)jarg1;
71377   arg2 = (float)jarg2;
71378   {
71379     try {
71380       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
71381     } catch (std::out_of_range& e) {
71382       {
71383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71384       };
71385     } catch (std::exception& e) {
71386       {
71387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71388       };
71389     } catch (...) {
71390       {
71391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71392       };
71393     }
71394   }
71395   jresult = (void *)result;
71396   return jresult;
71397 }
71398
71399
71400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
71401   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71402   float arg2 ;
71403
71404   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71405   arg2 = (float)jarg2;
71406   if (arg1) (arg1)->min = arg2;
71407 }
71408
71409
71410 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
71411   float jresult ;
71412   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71413   float result;
71414
71415   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71416   result = (float) ((arg1)->min);
71417   jresult = result;
71418   return jresult;
71419 }
71420
71421
71422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
71423   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71424   float arg2 ;
71425
71426   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71427   arg2 = (float)jarg2;
71428   if (arg1) (arg1)->max = arg2;
71429 }
71430
71431
71432 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
71433   float jresult ;
71434   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71435   float result;
71436
71437   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71438   result = (float) ((arg1)->max);
71439   jresult = result;
71440   return jresult;
71441 }
71442
71443
71444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
71445   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71446   bool arg2 ;
71447
71448   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71449   arg2 = jarg2 ? true : false;
71450   if (arg1) (arg1)->enabled = arg2;
71451 }
71452
71453
71454 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
71455   unsigned int jresult ;
71456   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71457   bool result;
71458
71459   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71460   result = (bool) ((arg1)->enabled);
71461   jresult = result;
71462   return jresult;
71463 }
71464
71465
71466 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
71467   float jresult ;
71468   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71469   float arg2 ;
71470   float arg3 ;
71471   float arg4 ;
71472   float result;
71473
71474   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71475   arg2 = (float)jarg2;
71476   arg3 = (float)jarg3;
71477   arg4 = (float)jarg4;
71478   {
71479     try {
71480       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
71481     } catch (std::out_of_range& e) {
71482       {
71483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71484       };
71485     } catch (std::exception& e) {
71486       {
71487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71488       };
71489     } catch (...) {
71490       {
71491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71492       };
71493     }
71494   }
71495   jresult = result;
71496   return jresult;
71497 }
71498
71499
71500 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
71501   float jresult ;
71502   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71503   float arg2 ;
71504   float arg3 ;
71505   float result;
71506
71507   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71508   arg2 = (float)jarg2;
71509   arg3 = (float)jarg3;
71510   {
71511     try {
71512       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
71513     } catch (std::out_of_range& e) {
71514       {
71515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71516       };
71517     } catch (std::exception& e) {
71518       {
71519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71520       };
71521     } catch (...) {
71522       {
71523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71524       };
71525     }
71526   }
71527   jresult = result;
71528   return jresult;
71529 }
71530
71531
71532 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
71533   float jresult ;
71534   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71535   float arg2 ;
71536   float result;
71537
71538   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71539   arg2 = (float)jarg2;
71540   {
71541     try {
71542       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
71543     } catch (std::out_of_range& e) {
71544       {
71545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71546       };
71547     } catch (std::exception& e) {
71548       {
71549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71550       };
71551     } catch (...) {
71552       {
71553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71554       };
71555     }
71556   }
71557   jresult = result;
71558   return jresult;
71559 }
71560
71561
71562 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
71563   float jresult ;
71564   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71565   float arg2 ;
71566   float arg3 ;
71567   float arg4 ;
71568   Dali::Toolkit::ClampState *arg5 = 0 ;
71569   float result;
71570
71571   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71572   arg2 = (float)jarg2;
71573   arg3 = (float)jarg3;
71574   arg4 = (float)jarg4;
71575   arg5 = (Dali::Toolkit::ClampState *)jarg5;
71576   if (!arg5) {
71577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
71578     return 0;
71579   }
71580   {
71581     try {
71582       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
71583     } catch (std::out_of_range& e) {
71584       {
71585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71586       };
71587     } catch (std::exception& e) {
71588       {
71589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71590       };
71591     } catch (...) {
71592       {
71593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71594       };
71595     }
71596   }
71597   jresult = result;
71598   return jresult;
71599 }
71600
71601
71602 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
71603   float jresult ;
71604   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71605   float result;
71606
71607   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71608   {
71609     try {
71610       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
71611     } catch (std::out_of_range& e) {
71612       {
71613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71614       };
71615     } catch (std::exception& e) {
71616       {
71617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71618       };
71619     } catch (...) {
71620       {
71621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71622       };
71623     }
71624   }
71625   jresult = result;
71626   return jresult;
71627 }
71628
71629
71630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
71631   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71632
71633   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71634   {
71635     try {
71636       delete arg1;
71637     } catch (std::out_of_range& e) {
71638       {
71639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71640       };
71641     } catch (std::exception& e) {
71642       {
71643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71644       };
71645     } catch (...) {
71646       {
71647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71648       };
71649     }
71650   }
71651 }
71652
71653
71654 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
71655   float jresult ;
71656   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71657   float arg2 ;
71658   float arg3 ;
71659   float result;
71660
71661   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71662   arg2 = (float)jarg2;
71663   arg3 = (float)jarg3;
71664   {
71665     try {
71666       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
71667     } catch (std::out_of_range& e) {
71668       {
71669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71670       };
71671     } catch (std::exception& e) {
71672       {
71673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71674       };
71675     } catch (...) {
71676       {
71677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71678       };
71679     }
71680   }
71681   jresult = result;
71682   return jresult;
71683 }
71684
71685
71686 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
71687   float jresult ;
71688   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71689   float arg2 ;
71690   float result;
71691
71692   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71693   arg2 = (float)jarg2;
71694   {
71695     try {
71696       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
71697     } catch (std::out_of_range& e) {
71698       {
71699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71700       };
71701     } catch (std::exception& e) {
71702       {
71703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71704       };
71705     } catch (...) {
71706       {
71707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71708       };
71709     }
71710   }
71711   jresult = result;
71712   return jresult;
71713 }
71714
71715
71716 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
71717   float jresult ;
71718   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71719   unsigned int arg2 ;
71720   unsigned int *arg3 = 0 ;
71721   bool arg4 ;
71722   float result;
71723
71724   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71725   arg2 = (unsigned int)jarg2;
71726   arg3 = (unsigned int *)jarg3;
71727   arg4 = jarg4 ? true : false;
71728   {
71729     try {
71730       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
71731     } catch (std::out_of_range& e) {
71732       {
71733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71734       };
71735     } catch (std::exception& e) {
71736       {
71737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71738       };
71739     } catch (...) {
71740       {
71741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71742       };
71743     }
71744   }
71745   jresult = result;
71746   return jresult;
71747 }
71748
71749
71750 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
71751   unsigned int jresult ;
71752   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71753   float arg2 ;
71754   bool arg3 ;
71755   unsigned int result;
71756
71757   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71758   arg2 = (float)jarg2;
71759   arg3 = jarg3 ? true : false;
71760   {
71761     try {
71762       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
71763     } catch (std::out_of_range& e) {
71764       {
71765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71766       };
71767     } catch (std::exception& e) {
71768       {
71769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71770       };
71771     } catch (...) {
71772       {
71773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71774       };
71775     }
71776   }
71777   jresult = result;
71778   return jresult;
71779 }
71780
71781
71782 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
71783   unsigned int jresult ;
71784   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71785   unsigned int result;
71786
71787   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71788   {
71789     try {
71790       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
71791     } catch (std::out_of_range& e) {
71792       {
71793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71794       };
71795     } catch (std::exception& e) {
71796       {
71797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71798       };
71799     } catch (...) {
71800       {
71801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71802       };
71803     }
71804   }
71805   jresult = result;
71806   return jresult;
71807 }
71808
71809
71810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
71811   int jresult ;
71812   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71813   Dali::Toolkit::Ruler::RulerType result;
71814
71815   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71816   {
71817     try {
71818       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
71819     } catch (std::out_of_range& e) {
71820       {
71821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71822       };
71823     } catch (std::exception& e) {
71824       {
71825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71826       };
71827     } catch (...) {
71828       {
71829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71830       };
71831     }
71832   }
71833   jresult = (int)result;
71834   return jresult;
71835 }
71836
71837
71838 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
71839   unsigned int jresult ;
71840   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71841   bool result;
71842
71843   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71844   {
71845     try {
71846       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
71847     } catch (std::out_of_range& e) {
71848       {
71849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71850       };
71851     } catch (std::exception& e) {
71852       {
71853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71854       };
71855     } catch (...) {
71856       {
71857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71858       };
71859     }
71860   }
71861   jresult = result;
71862   return jresult;
71863 }
71864
71865
71866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
71867   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71868
71869   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71870   {
71871     try {
71872       (arg1)->Enable();
71873     } catch (std::out_of_range& e) {
71874       {
71875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71876       };
71877     } catch (std::exception& e) {
71878       {
71879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71880       };
71881     } catch (...) {
71882       {
71883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71884       };
71885     }
71886   }
71887 }
71888
71889
71890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
71891   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71892
71893   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71894   {
71895     try {
71896       (arg1)->Disable();
71897     } catch (std::out_of_range& e) {
71898       {
71899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71900       };
71901     } catch (std::exception& e) {
71902       {
71903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71904       };
71905     } catch (...) {
71906       {
71907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71908       };
71909     }
71910   }
71911 }
71912
71913
71914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
71915   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71916   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
71917   Dali::Toolkit::RulerDomain *argp2 ;
71918
71919   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71920   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
71921   if (!argp2) {
71922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
71923     return ;
71924   }
71925   arg2 = *argp2;
71926   {
71927     try {
71928       (arg1)->SetDomain(arg2);
71929     } catch (std::out_of_range& e) {
71930       {
71931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71932       };
71933     } catch (std::exception& e) {
71934       {
71935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71936       };
71937     } catch (...) {
71938       {
71939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71940       };
71941     }
71942   }
71943 }
71944
71945
71946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
71947   void * jresult ;
71948   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71949   Dali::Toolkit::RulerDomain *result = 0 ;
71950
71951   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71952   {
71953     try {
71954       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
71955     } catch (std::out_of_range& e) {
71956       {
71957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71958       };
71959     } catch (std::exception& e) {
71960       {
71961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71962       };
71963     } catch (...) {
71964       {
71965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71966       };
71967     }
71968   }
71969   jresult = (void *)result;
71970   return jresult;
71971 }
71972
71973
71974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
71975   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71976
71977   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71978   {
71979     try {
71980       (arg1)->DisableDomain();
71981     } catch (std::out_of_range& e) {
71982       {
71983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71984       };
71985     } catch (std::exception& e) {
71986       {
71987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71988       };
71989     } catch (...) {
71990       {
71991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71992       };
71993     }
71994   }
71995 }
71996
71997
71998 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
71999   float jresult ;
72000   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72001   float arg2 ;
72002   float arg3 ;
72003   float arg4 ;
72004   float result;
72005
72006   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72007   arg2 = (float)jarg2;
72008   arg3 = (float)jarg3;
72009   arg4 = (float)jarg4;
72010   {
72011     try {
72012       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
72013     } catch (std::out_of_range& e) {
72014       {
72015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72016       };
72017     } catch (std::exception& e) {
72018       {
72019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72020       };
72021     } catch (...) {
72022       {
72023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72024       };
72025     }
72026   }
72027   jresult = result;
72028   return jresult;
72029 }
72030
72031
72032 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
72033   float jresult ;
72034   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72035   float arg2 ;
72036   float arg3 ;
72037   float result;
72038
72039   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72040   arg2 = (float)jarg2;
72041   arg3 = (float)jarg3;
72042   {
72043     try {
72044       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
72045     } catch (std::out_of_range& e) {
72046       {
72047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72048       };
72049     } catch (std::exception& e) {
72050       {
72051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72052       };
72053     } catch (...) {
72054       {
72055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72056       };
72057     }
72058   }
72059   jresult = result;
72060   return jresult;
72061 }
72062
72063
72064 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
72065   float jresult ;
72066   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72067   float arg2 ;
72068   float result;
72069
72070   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72071   arg2 = (float)jarg2;
72072   {
72073     try {
72074       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
72075     } catch (std::out_of_range& e) {
72076       {
72077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72078       };
72079     } catch (std::exception& e) {
72080       {
72081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72082       };
72083     } catch (...) {
72084       {
72085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72086       };
72087     }
72088   }
72089   jresult = result;
72090   return jresult;
72091 }
72092
72093
72094 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
72095   float jresult ;
72096   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72097   float arg2 ;
72098   float arg3 ;
72099   float arg4 ;
72100   Dali::Toolkit::ClampState *arg5 = 0 ;
72101   float result;
72102
72103   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72104   arg2 = (float)jarg2;
72105   arg3 = (float)jarg3;
72106   arg4 = (float)jarg4;
72107   arg5 = (Dali::Toolkit::ClampState *)jarg5;
72108   if (!arg5) {
72109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72110     return 0;
72111   }
72112   {
72113     try {
72114       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
72115     } catch (std::out_of_range& e) {
72116       {
72117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72118       };
72119     } catch (std::exception& e) {
72120       {
72121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72122       };
72123     } catch (...) {
72124       {
72125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72126       };
72127     }
72128   }
72129   jresult = result;
72130   return jresult;
72131 }
72132
72133
72134 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
72135   float jresult ;
72136   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72137   float arg2 ;
72138   float arg3 ;
72139   float arg4 ;
72140   float arg5 ;
72141   float result;
72142
72143   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72144   arg2 = (float)jarg2;
72145   arg3 = (float)jarg3;
72146   arg4 = (float)jarg4;
72147   arg5 = (float)jarg5;
72148   {
72149     try {
72150       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
72151     } catch (std::out_of_range& e) {
72152       {
72153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72154       };
72155     } catch (std::exception& e) {
72156       {
72157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72158       };
72159     } catch (...) {
72160       {
72161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72162       };
72163     }
72164   }
72165   jresult = result;
72166   return jresult;
72167 }
72168
72169
72170 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
72171   float jresult ;
72172   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72173   float arg2 ;
72174   float arg3 ;
72175   float arg4 ;
72176   float result;
72177
72178   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72179   arg2 = (float)jarg2;
72180   arg3 = (float)jarg3;
72181   arg4 = (float)jarg4;
72182   {
72183     try {
72184       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
72185     } catch (std::out_of_range& e) {
72186       {
72187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72188       };
72189     } catch (std::exception& e) {
72190       {
72191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72192       };
72193     } catch (...) {
72194       {
72195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72196       };
72197     }
72198   }
72199   jresult = result;
72200   return jresult;
72201 }
72202
72203
72204 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
72205   float jresult ;
72206   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72207   float arg2 ;
72208   float arg3 ;
72209   float result;
72210
72211   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72212   arg2 = (float)jarg2;
72213   arg3 = (float)jarg3;
72214   {
72215     try {
72216       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
72217     } catch (std::out_of_range& e) {
72218       {
72219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72220       };
72221     } catch (std::exception& e) {
72222       {
72223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72224       };
72225     } catch (...) {
72226       {
72227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72228       };
72229     }
72230   }
72231   jresult = result;
72232   return jresult;
72233 }
72234
72235
72236 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
72237   float jresult ;
72238   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72239   float arg2 ;
72240   float result;
72241
72242   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72243   arg2 = (float)jarg2;
72244   {
72245     try {
72246       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
72247     } catch (std::out_of_range& e) {
72248       {
72249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72250       };
72251     } catch (std::exception& e) {
72252       {
72253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72254       };
72255     } catch (...) {
72256       {
72257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72258       };
72259     }
72260   }
72261   jresult = result;
72262   return jresult;
72263 }
72264
72265
72266 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
72267   float jresult ;
72268   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72269   float arg2 ;
72270   float arg3 ;
72271   float arg4 ;
72272   float arg5 ;
72273   Dali::Toolkit::ClampState *arg6 = 0 ;
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   arg6 = (Dali::Toolkit::ClampState *)jarg6;
72282   if (!arg6) {
72283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72284     return 0;
72285   }
72286   {
72287     try {
72288       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
72289     } catch (std::out_of_range& e) {
72290       {
72291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72292       };
72293     } catch (std::exception& e) {
72294       {
72295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72296       };
72297     } catch (...) {
72298       {
72299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72300       };
72301     }
72302   }
72303   jresult = result;
72304   return jresult;
72305 }
72306
72307
72308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
72309   void * jresult ;
72310   Dali::Toolkit::DefaultRuler *result = 0 ;
72311
72312   {
72313     try {
72314       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
72315     } catch (std::out_of_range& e) {
72316       {
72317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72318       };
72319     } catch (std::exception& e) {
72320       {
72321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72322       };
72323     } catch (...) {
72324       {
72325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72326       };
72327     }
72328   }
72329   jresult = (void *)result;
72330   return jresult;
72331 }
72332
72333
72334 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
72335   float jresult ;
72336   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72337   float arg2 ;
72338   float arg3 ;
72339   float result;
72340
72341   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72342   arg2 = (float)jarg2;
72343   arg3 = (float)jarg3;
72344   {
72345     try {
72346       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
72347     } catch (std::out_of_range& e) {
72348       {
72349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72350       };
72351     } catch (std::exception& e) {
72352       {
72353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72354       };
72355     } catch (...) {
72356       {
72357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72358       };
72359     }
72360   }
72361   jresult = result;
72362   return jresult;
72363 }
72364
72365
72366 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72367   float jresult ;
72368   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72369   unsigned int arg2 ;
72370   unsigned int *arg3 = 0 ;
72371   bool arg4 ;
72372   float result;
72373
72374   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72375   arg2 = (unsigned int)jarg2;
72376   arg3 = (unsigned int *)jarg3;
72377   arg4 = jarg4 ? true : false;
72378   {
72379     try {
72380       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72381     } catch (std::out_of_range& e) {
72382       {
72383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72384       };
72385     } catch (std::exception& e) {
72386       {
72387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72388       };
72389     } catch (...) {
72390       {
72391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72392       };
72393     }
72394   }
72395   jresult = result;
72396   return jresult;
72397 }
72398
72399
72400 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72401   unsigned int jresult ;
72402   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72403   float arg2 ;
72404   bool arg3 ;
72405   unsigned int result;
72406
72407   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72408   arg2 = (float)jarg2;
72409   arg3 = jarg3 ? true : false;
72410   {
72411     try {
72412       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
72413     } catch (std::out_of_range& e) {
72414       {
72415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72416       };
72417     } catch (std::exception& e) {
72418       {
72419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72420       };
72421     } catch (...) {
72422       {
72423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72424       };
72425     }
72426   }
72427   jresult = result;
72428   return jresult;
72429 }
72430
72431
72432 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
72433   unsigned int jresult ;
72434   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72435   unsigned int result;
72436
72437   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72438   {
72439     try {
72440       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
72441     } catch (std::out_of_range& e) {
72442       {
72443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72444       };
72445     } catch (std::exception& e) {
72446       {
72447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72448       };
72449     } catch (...) {
72450       {
72451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72452       };
72453     }
72454   }
72455   jresult = result;
72456   return jresult;
72457 }
72458
72459
72460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
72461   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72462
72463   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72464   {
72465     try {
72466       delete arg1;
72467     } catch (std::out_of_range& e) {
72468       {
72469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72470       };
72471     } catch (std::exception& e) {
72472       {
72473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72474       };
72475     } catch (...) {
72476       {
72477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72478       };
72479     }
72480   }
72481 }
72482
72483
72484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
72485   void * jresult ;
72486   float arg1 ;
72487   Dali::Toolkit::FixedRuler *result = 0 ;
72488
72489   arg1 = (float)jarg1;
72490   {
72491     try {
72492       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
72493     } catch (std::out_of_range& e) {
72494       {
72495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72496       };
72497     } catch (std::exception& e) {
72498       {
72499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72500       };
72501     } catch (...) {
72502       {
72503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72504       };
72505     }
72506   }
72507   jresult = (void *)result;
72508   return jresult;
72509 }
72510
72511
72512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
72513   void * jresult ;
72514   Dali::Toolkit::FixedRuler *result = 0 ;
72515
72516   {
72517     try {
72518       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
72519     } catch (std::out_of_range& e) {
72520       {
72521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72522       };
72523     } catch (std::exception& e) {
72524       {
72525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72526       };
72527     } catch (...) {
72528       {
72529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72530       };
72531     }
72532   }
72533   jresult = (void *)result;
72534   return jresult;
72535 }
72536
72537
72538 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
72539   float jresult ;
72540   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72541   float arg2 ;
72542   float arg3 ;
72543   float result;
72544
72545   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72546   arg2 = (float)jarg2;
72547   arg3 = (float)jarg3;
72548   {
72549     try {
72550       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
72551     } catch (std::out_of_range& e) {
72552       {
72553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72554       };
72555     } catch (std::exception& e) {
72556       {
72557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72558       };
72559     } catch (...) {
72560       {
72561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72562       };
72563     }
72564   }
72565   jresult = result;
72566   return jresult;
72567 }
72568
72569
72570 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72571   float jresult ;
72572   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72573   unsigned int arg2 ;
72574   unsigned int *arg3 = 0 ;
72575   bool arg4 ;
72576   float result;
72577
72578   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72579   arg2 = (unsigned int)jarg2;
72580   arg3 = (unsigned int *)jarg3;
72581   arg4 = jarg4 ? true : false;
72582   {
72583     try {
72584       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72585     } catch (std::out_of_range& e) {
72586       {
72587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72588       };
72589     } catch (std::exception& e) {
72590       {
72591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72592       };
72593     } catch (...) {
72594       {
72595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72596       };
72597     }
72598   }
72599   jresult = result;
72600   return jresult;
72601 }
72602
72603
72604 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72605   unsigned int jresult ;
72606   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72607   float arg2 ;
72608   bool arg3 ;
72609   unsigned int result;
72610
72611   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72612   arg2 = (float)jarg2;
72613   arg3 = jarg3 ? true : false;
72614   {
72615     try {
72616       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
72617     } catch (std::out_of_range& e) {
72618       {
72619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72620       };
72621     } catch (std::exception& e) {
72622       {
72623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72624       };
72625     } catch (...) {
72626       {
72627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72628       };
72629     }
72630   }
72631   jresult = result;
72632   return jresult;
72633 }
72634
72635
72636 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
72637   unsigned int jresult ;
72638   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72639   unsigned int result;
72640
72641   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72642   {
72643     try {
72644       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
72645     } catch (std::out_of_range& e) {
72646       {
72647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72648       };
72649     } catch (std::exception& e) {
72650       {
72651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72652       };
72653     } catch (...) {
72654       {
72655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72656       };
72657     }
72658   }
72659   jresult = result;
72660   return jresult;
72661 }
72662
72663
72664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
72665   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72666
72667   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72668   {
72669     try {
72670       delete arg1;
72671     } catch (std::out_of_range& e) {
72672       {
72673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72674       };
72675     } catch (std::exception& e) {
72676       {
72677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72678       };
72679     } catch (...) {
72680       {
72681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72682       };
72683     }
72684   }
72685 }
72686
72687
72688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
72689   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72690   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
72691
72692   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72693   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
72694   if (arg1) (arg1)->scale = *arg2;
72695 }
72696
72697
72698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
72699   void * jresult ;
72700   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72701   Dali::Toolkit::ClampState2D *result = 0 ;
72702
72703   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72704   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
72705   jresult = (void *)result;
72706   return jresult;
72707 }
72708
72709
72710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
72711   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72712   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
72713
72714   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72715   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
72716   if (arg1) (arg1)->position = *arg2;
72717 }
72718
72719
72720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
72721   void * jresult ;
72722   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72723   Dali::Toolkit::ClampState2D *result = 0 ;
72724
72725   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72726   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
72727   jresult = (void *)result;
72728   return jresult;
72729 }
72730
72731
72732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
72733   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72734   Dali::Toolkit::ClampState arg2 ;
72735
72736   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72737   arg2 = (Dali::Toolkit::ClampState)jarg2;
72738   if (arg1) (arg1)->rotation = arg2;
72739 }
72740
72741
72742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
72743   int jresult ;
72744   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72745   Dali::Toolkit::ClampState result;
72746
72747   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72748   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
72749   jresult = (int)result;
72750   return jresult;
72751 }
72752
72753
72754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
72755   void * jresult ;
72756   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
72757
72758   {
72759     try {
72760       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
72761     } catch (std::out_of_range& e) {
72762       {
72763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72764       };
72765     } catch (std::exception& e) {
72766       {
72767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72768       };
72769     } catch (...) {
72770       {
72771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72772       };
72773     }
72774   }
72775   jresult = (void *)result;
72776   return jresult;
72777 }
72778
72779
72780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
72781   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72782
72783   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72784   {
72785     try {
72786       delete arg1;
72787     } catch (std::out_of_range& e) {
72788       {
72789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72790       };
72791     } catch (std::exception& e) {
72792       {
72793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72794       };
72795     } catch (...) {
72796       {
72797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72798       };
72799     }
72800   }
72801 }
72802
72803
72804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
72805   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72806   Dali::Toolkit::SnapType arg2 ;
72807
72808   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72809   arg2 = (Dali::Toolkit::SnapType)jarg2;
72810   if (arg1) (arg1)->type = arg2;
72811 }
72812
72813
72814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
72815   int jresult ;
72816   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72817   Dali::Toolkit::SnapType result;
72818
72819   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72820   result = (Dali::Toolkit::SnapType) ((arg1)->type);
72821   jresult = (int)result;
72822   return jresult;
72823 }
72824
72825
72826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
72827   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72828   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
72829
72830   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72831   arg2 = (Dali::Vector2 *)jarg2;
72832   if (arg1) (arg1)->position = *arg2;
72833 }
72834
72835
72836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
72837   void * jresult ;
72838   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72839   Dali::Vector2 *result = 0 ;
72840
72841   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72842   result = (Dali::Vector2 *)& ((arg1)->position);
72843   jresult = (void *)result;
72844   return jresult;
72845 }
72846
72847
72848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
72849   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72850   float arg2 ;
72851
72852   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72853   arg2 = (float)jarg2;
72854   if (arg1) (arg1)->duration = arg2;
72855 }
72856
72857
72858 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
72859   float jresult ;
72860   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72861   float result;
72862
72863   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72864   result = (float) ((arg1)->duration);
72865   jresult = result;
72866   return jresult;
72867 }
72868
72869
72870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
72871   void * jresult ;
72872   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
72873
72874   {
72875     try {
72876       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
72877     } catch (std::out_of_range& e) {
72878       {
72879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72880       };
72881     } catch (std::exception& e) {
72882       {
72883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72884       };
72885     } catch (...) {
72886       {
72887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72888       };
72889     }
72890   }
72891   jresult = (void *)result;
72892   return jresult;
72893 }
72894
72895
72896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
72897   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72898
72899   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72900   {
72901     try {
72902       delete arg1;
72903     } catch (std::out_of_range& e) {
72904       {
72905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72906       };
72907     } catch (std::exception& e) {
72908       {
72909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72910       };
72911     } catch (...) {
72912       {
72913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72914       };
72915     }
72916   }
72917 }
72918
72919
72920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
72921   int jresult ;
72922   int result;
72923
72924   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
72925   jresult = (int)result;
72926   return jresult;
72927 }
72928
72929
72930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
72931   int jresult ;
72932   int result;
72933
72934   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
72935   jresult = (int)result;
72936   return jresult;
72937 }
72938
72939
72940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
72941   int jresult ;
72942   int result;
72943
72944   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
72945   jresult = (int)result;
72946   return jresult;
72947 }
72948
72949
72950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
72951   int jresult ;
72952   int result;
72953
72954   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
72955   jresult = (int)result;
72956   return jresult;
72957 }
72958
72959
72960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
72961   int jresult ;
72962   int result;
72963
72964   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
72965   jresult = (int)result;
72966   return jresult;
72967 }
72968
72969
72970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
72971   int jresult ;
72972   int result;
72973
72974   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
72975   jresult = (int)result;
72976   return jresult;
72977 }
72978
72979
72980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
72981   int jresult ;
72982   int result;
72983
72984   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
72985   jresult = (int)result;
72986   return jresult;
72987 }
72988
72989
72990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
72991   int jresult ;
72992   int result;
72993
72994   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
72995   jresult = (int)result;
72996   return jresult;
72997 }
72998
72999
73000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
73001   int jresult ;
73002   int result;
73003
73004   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
73005   jresult = (int)result;
73006   return jresult;
73007 }
73008
73009
73010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
73011   int jresult ;
73012   int result;
73013
73014   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
73015   jresult = (int)result;
73016   return jresult;
73017 }
73018
73019
73020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
73021   int jresult ;
73022   int result;
73023
73024   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
73025   jresult = (int)result;
73026   return jresult;
73027 }
73028
73029
73030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
73031   int jresult ;
73032   int result;
73033
73034   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
73035   jresult = (int)result;
73036   return jresult;
73037 }
73038
73039
73040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
73041   int jresult ;
73042   int result;
73043
73044   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
73045   jresult = (int)result;
73046   return jresult;
73047 }
73048
73049
73050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
73051   int jresult ;
73052   int result;
73053
73054   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
73055   jresult = (int)result;
73056   return jresult;
73057 }
73058
73059
73060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
73061   int jresult ;
73062   int result;
73063
73064   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
73065   jresult = (int)result;
73066   return jresult;
73067 }
73068
73069
73070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
73071   int jresult ;
73072   int result;
73073
73074   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
73075   jresult = (int)result;
73076   return jresult;
73077 }
73078
73079
73080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
73081   int jresult ;
73082   int result;
73083
73084   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
73085   jresult = (int)result;
73086   return jresult;
73087 }
73088
73089
73090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
73091   int jresult ;
73092   int result;
73093
73094   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
73095   jresult = (int)result;
73096   return jresult;
73097 }
73098
73099
73100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
73101   int jresult ;
73102   int result;
73103
73104   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
73105   jresult = (int)result;
73106   return jresult;
73107 }
73108
73109
73110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
73111   int jresult ;
73112   int result;
73113
73114   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
73115   jresult = (int)result;
73116   return jresult;
73117 }
73118
73119
73120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
73121   int jresult ;
73122   int result;
73123
73124   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
73125   jresult = (int)result;
73126   return jresult;
73127 }
73128
73129
73130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
73131   int jresult ;
73132   int result;
73133
73134   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
73135   jresult = (int)result;
73136   return jresult;
73137 }
73138
73139
73140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
73141   int jresult ;
73142   int result;
73143
73144   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
73145   jresult = (int)result;
73146   return jresult;
73147 }
73148
73149
73150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
73151   int jresult ;
73152   int result;
73153
73154   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
73155   jresult = (int)result;
73156   return jresult;
73157 }
73158
73159
73160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
73161   int jresult ;
73162   int result;
73163
73164   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
73165   jresult = (int)result;
73166   return jresult;
73167 }
73168
73169
73170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
73171   void * jresult ;
73172   Dali::Toolkit::ScrollView::Property *result = 0 ;
73173
73174   {
73175     try {
73176       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
73177     } catch (std::out_of_range& e) {
73178       {
73179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73180       };
73181     } catch (std::exception& e) {
73182       {
73183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73184       };
73185     } catch (...) {
73186       {
73187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73188       };
73189     }
73190   }
73191   jresult = (void *)result;
73192   return jresult;
73193 }
73194
73195
73196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
73197   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
73198
73199   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
73200   {
73201     try {
73202       delete arg1;
73203     } catch (std::out_of_range& e) {
73204       {
73205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73206       };
73207     } catch (std::exception& e) {
73208       {
73209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73210       };
73211     } catch (...) {
73212       {
73213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73214       };
73215     }
73216   }
73217 }
73218
73219
73220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
73221   void * jresult ;
73222   Dali::Toolkit::ScrollView *result = 0 ;
73223
73224   {
73225     try {
73226       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
73227     } catch (std::out_of_range& e) {
73228       {
73229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73230       };
73231     } catch (std::exception& e) {
73232       {
73233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73234       };
73235     } catch (...) {
73236       {
73237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73238       };
73239     }
73240   }
73241   jresult = (void *)result;
73242   return jresult;
73243 }
73244
73245
73246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
73247   void * jresult ;
73248   Dali::Toolkit::ScrollView *arg1 = 0 ;
73249   Dali::Toolkit::ScrollView *result = 0 ;
73250
73251   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73252   if (!arg1) {
73253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
73254     return 0;
73255   }
73256   {
73257     try {
73258       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
73259     } catch (std::out_of_range& e) {
73260       {
73261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73262       };
73263     } catch (std::exception& e) {
73264       {
73265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73266       };
73267     } catch (...) {
73268       {
73269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73270       };
73271     }
73272   }
73273   jresult = (void *)result;
73274   return jresult;
73275 }
73276
73277
73278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
73279   void * jresult ;
73280   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73281   Dali::Toolkit::ScrollView *arg2 = 0 ;
73282   Dali::Toolkit::ScrollView *result = 0 ;
73283
73284   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73285   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
73286   if (!arg2) {
73287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
73288     return 0;
73289   }
73290   {
73291     try {
73292       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
73293     } catch (std::out_of_range& e) {
73294       {
73295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73296       };
73297     } catch (std::exception& e) {
73298       {
73299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73300       };
73301     } catch (...) {
73302       {
73303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73304       };
73305     }
73306   }
73307   jresult = (void *)result;
73308   return jresult;
73309 }
73310
73311
73312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
73313   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73314
73315   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73316   {
73317     try {
73318       delete arg1;
73319     } catch (std::out_of_range& e) {
73320       {
73321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73322       };
73323     } catch (std::exception& e) {
73324       {
73325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73326       };
73327     } catch (...) {
73328       {
73329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73330       };
73331     }
73332   }
73333 }
73334
73335
73336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
73337   void * jresult ;
73338   Dali::Toolkit::ScrollView result;
73339
73340   {
73341     try {
73342       result = Dali::Toolkit::ScrollView::New();
73343     } catch (std::out_of_range& e) {
73344       {
73345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73346       };
73347     } catch (std::exception& e) {
73348       {
73349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73350       };
73351     } catch (...) {
73352       {
73353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73354       };
73355     }
73356   }
73357   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
73358   return jresult;
73359 }
73360
73361
73362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
73363   void * jresult ;
73364   Dali::BaseHandle arg1 ;
73365   Dali::BaseHandle *argp1 ;
73366   Dali::Toolkit::ScrollView result;
73367
73368   argp1 = (Dali::BaseHandle *)jarg1;
73369   if (!argp1) {
73370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73371     return 0;
73372   }
73373   arg1 = *argp1;
73374   {
73375     try {
73376       result = Dali::Toolkit::ScrollView::DownCast(arg1);
73377     } catch (std::out_of_range& e) {
73378       {
73379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73380       };
73381     } catch (std::exception& e) {
73382       {
73383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73384       };
73385     } catch (...) {
73386       {
73387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73388       };
73389     }
73390   }
73391   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
73392   return jresult;
73393 }
73394
73395
73396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
73397   void * jresult ;
73398   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73399   Dali::AlphaFunction result;
73400
73401   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73402   {
73403     try {
73404       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
73405     } catch (std::out_of_range& e) {
73406       {
73407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73408       };
73409     } catch (std::exception& e) {
73410       {
73411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73412       };
73413     } catch (...) {
73414       {
73415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73416       };
73417     }
73418   }
73419   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
73420   return jresult;
73421 }
73422
73423
73424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
73425   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73426   Dali::AlphaFunction arg2 ;
73427   Dali::AlphaFunction *argp2 ;
73428
73429   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73430   argp2 = (Dali::AlphaFunction *)jarg2;
73431   if (!argp2) {
73432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
73433     return ;
73434   }
73435   arg2 = *argp2;
73436   {
73437     try {
73438       (arg1)->SetScrollSnapAlphaFunction(arg2);
73439     } catch (std::out_of_range& e) {
73440       {
73441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73442       };
73443     } catch (std::exception& e) {
73444       {
73445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73446       };
73447     } catch (...) {
73448       {
73449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73450       };
73451     }
73452   }
73453 }
73454
73455
73456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
73457   void * jresult ;
73458   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73459   Dali::AlphaFunction result;
73460
73461   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73462   {
73463     try {
73464       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
73465     } catch (std::out_of_range& e) {
73466       {
73467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73468       };
73469     } catch (std::exception& e) {
73470       {
73471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73472       };
73473     } catch (...) {
73474       {
73475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73476       };
73477     }
73478   }
73479   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
73480   return jresult;
73481 }
73482
73483
73484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
73485   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73486   Dali::AlphaFunction arg2 ;
73487   Dali::AlphaFunction *argp2 ;
73488
73489   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73490   argp2 = (Dali::AlphaFunction *)jarg2;
73491   if (!argp2) {
73492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
73493     return ;
73494   }
73495   arg2 = *argp2;
73496   {
73497     try {
73498       (arg1)->SetScrollFlickAlphaFunction(arg2);
73499     } catch (std::out_of_range& e) {
73500       {
73501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73502       };
73503     } catch (std::exception& e) {
73504       {
73505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73506       };
73507     } catch (...) {
73508       {
73509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73510       };
73511     }
73512   }
73513 }
73514
73515
73516 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
73517   float jresult ;
73518   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73519   float result;
73520
73521   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73522   {
73523     try {
73524       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
73525     } catch (std::out_of_range& e) {
73526       {
73527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73528       };
73529     } catch (std::exception& e) {
73530       {
73531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73532       };
73533     } catch (...) {
73534       {
73535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73536       };
73537     }
73538   }
73539   jresult = result;
73540   return jresult;
73541 }
73542
73543
73544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
73545   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73546   float arg2 ;
73547
73548   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73549   arg2 = (float)jarg2;
73550   {
73551     try {
73552       (arg1)->SetScrollSnapDuration(arg2);
73553     } catch (std::out_of_range& e) {
73554       {
73555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73556       };
73557     } catch (std::exception& e) {
73558       {
73559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73560       };
73561     } catch (...) {
73562       {
73563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73564       };
73565     }
73566   }
73567 }
73568
73569
73570 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
73571   float jresult ;
73572   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73573   float result;
73574
73575   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73576   {
73577     try {
73578       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
73579     } catch (std::out_of_range& e) {
73580       {
73581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73582       };
73583     } catch (std::exception& e) {
73584       {
73585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73586       };
73587     } catch (...) {
73588       {
73589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73590       };
73591     }
73592   }
73593   jresult = result;
73594   return jresult;
73595 }
73596
73597
73598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
73599   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73600   float arg2 ;
73601
73602   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73603   arg2 = (float)jarg2;
73604   {
73605     try {
73606       (arg1)->SetScrollFlickDuration(arg2);
73607     } catch (std::out_of_range& e) {
73608       {
73609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73610       };
73611     } catch (std::exception& e) {
73612       {
73613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73614       };
73615     } catch (...) {
73616       {
73617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73618       };
73619     }
73620   }
73621 }
73622
73623
73624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
73625   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73626   Dali::Toolkit::RulerPtr arg2 ;
73627   Dali::Toolkit::RulerPtr *argp2 ;
73628
73629   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73630   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
73631   if (!argp2) {
73632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
73633     return ;
73634   }
73635   arg2 = *argp2;
73636   {
73637     try {
73638       (arg1)->SetRulerX(arg2);
73639     } catch (std::out_of_range& e) {
73640       {
73641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73642       };
73643     } catch (std::exception& e) {
73644       {
73645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73646       };
73647     } catch (...) {
73648       {
73649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73650       };
73651     }
73652   }
73653 }
73654
73655
73656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
73657   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73658   Dali::Toolkit::RulerPtr arg2 ;
73659   Dali::Toolkit::RulerPtr *argp2 ;
73660
73661   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73662   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
73663   if (!argp2) {
73664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
73665     return ;
73666   }
73667   arg2 = *argp2;
73668   {
73669     try {
73670       (arg1)->SetRulerY(arg2);
73671     } catch (std::out_of_range& e) {
73672       {
73673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73674       };
73675     } catch (std::exception& e) {
73676       {
73677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73678       };
73679     } catch (...) {
73680       {
73681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73682       };
73683     }
73684   }
73685 }
73686
73687
73688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
73689   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73690   bool arg2 ;
73691
73692   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73693   arg2 = jarg2 ? true : false;
73694   {
73695     try {
73696       (arg1)->SetScrollSensitive(arg2);
73697     } catch (std::out_of_range& e) {
73698       {
73699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73700       };
73701     } catch (std::exception& e) {
73702       {
73703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73704       };
73705     } catch (...) {
73706       {
73707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73708       };
73709     }
73710   }
73711 }
73712
73713
73714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
73715   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73716   float arg2 ;
73717   float arg3 ;
73718
73719   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73720   arg2 = (float)jarg2;
73721   arg3 = (float)jarg3;
73722   {
73723     try {
73724       (arg1)->SetMaxOvershoot(arg2,arg3);
73725     } catch (std::out_of_range& e) {
73726       {
73727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73728       };
73729     } catch (std::exception& e) {
73730       {
73731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73732       };
73733     } catch (...) {
73734       {
73735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73736       };
73737     }
73738   }
73739 }
73740
73741
73742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
73743   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73744   Dali::AlphaFunction arg2 ;
73745   Dali::AlphaFunction *argp2 ;
73746
73747   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73748   argp2 = (Dali::AlphaFunction *)jarg2;
73749   if (!argp2) {
73750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
73751     return ;
73752   }
73753   arg2 = *argp2;
73754   {
73755     try {
73756       (arg1)->SetSnapOvershootAlphaFunction(arg2);
73757     } catch (std::out_of_range& e) {
73758       {
73759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73760       };
73761     } catch (std::exception& e) {
73762       {
73763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73764       };
73765     } catch (...) {
73766       {
73767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73768       };
73769     }
73770   }
73771 }
73772
73773
73774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
73775   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73776   float arg2 ;
73777
73778   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73779   arg2 = (float)jarg2;
73780   {
73781     try {
73782       (arg1)->SetSnapOvershootDuration(arg2);
73783     } catch (std::out_of_range& e) {
73784       {
73785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73786       };
73787     } catch (std::exception& e) {
73788       {
73789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73790       };
73791     } catch (...) {
73792       {
73793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73794       };
73795     }
73796   }
73797 }
73798
73799
73800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
73801   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73802   bool arg2 ;
73803
73804   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73805   arg2 = jarg2 ? true : false;
73806   {
73807     try {
73808       (arg1)->SetActorAutoSnap(arg2);
73809     } catch (std::out_of_range& e) {
73810       {
73811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73812       };
73813     } catch (std::exception& e) {
73814       {
73815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73816       };
73817     } catch (...) {
73818       {
73819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73820       };
73821     }
73822   }
73823 }
73824
73825
73826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
73827   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73828   bool arg2 ;
73829
73830   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73831   arg2 = jarg2 ? true : false;
73832   {
73833     try {
73834       (arg1)->SetWrapMode(arg2);
73835     } catch (std::out_of_range& e) {
73836       {
73837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73838       };
73839     } catch (std::exception& e) {
73840       {
73841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73842       };
73843     } catch (...) {
73844       {
73845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73846       };
73847     }
73848   }
73849 }
73850
73851
73852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
73853   int jresult ;
73854   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73855   int result;
73856
73857   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73858   {
73859     try {
73860       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
73861     } catch (std::out_of_range& e) {
73862       {
73863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73864       };
73865     } catch (std::exception& e) {
73866       {
73867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73868       };
73869     } catch (...) {
73870       {
73871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73872       };
73873     }
73874   }
73875   jresult = result;
73876   return jresult;
73877 }
73878
73879
73880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
73881   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73882   int arg2 ;
73883
73884   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73885   arg2 = (int)jarg2;
73886   {
73887     try {
73888       (arg1)->SetScrollUpdateDistance(arg2);
73889     } catch (std::out_of_range& e) {
73890       {
73891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73892       };
73893     } catch (std::exception& e) {
73894       {
73895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73896       };
73897     } catch (...) {
73898       {
73899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73900       };
73901     }
73902   }
73903 }
73904
73905
73906 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
73907   unsigned int jresult ;
73908   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73909   bool result;
73910
73911   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73912   {
73913     try {
73914       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
73915     } catch (std::out_of_range& e) {
73916       {
73917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73918       };
73919     } catch (std::exception& e) {
73920       {
73921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73922       };
73923     } catch (...) {
73924       {
73925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73926       };
73927     }
73928   }
73929   jresult = result;
73930   return jresult;
73931 }
73932
73933
73934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
73935   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73936   bool arg2 ;
73937
73938   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73939   arg2 = jarg2 ? true : false;
73940   {
73941     try {
73942       (arg1)->SetAxisAutoLock(arg2);
73943     } catch (std::out_of_range& e) {
73944       {
73945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73946       };
73947     } catch (std::exception& e) {
73948       {
73949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73950       };
73951     } catch (...) {
73952       {
73953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73954       };
73955     }
73956   }
73957 }
73958
73959
73960 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
73961   float jresult ;
73962   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73963   float result;
73964
73965   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73966   {
73967     try {
73968       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
73969     } catch (std::out_of_range& e) {
73970       {
73971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73972       };
73973     } catch (std::exception& e) {
73974       {
73975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73976       };
73977     } catch (...) {
73978       {
73979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73980       };
73981     }
73982   }
73983   jresult = result;
73984   return jresult;
73985 }
73986
73987
73988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
73989   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73990   float arg2 ;
73991
73992   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73993   arg2 = (float)jarg2;
73994   {
73995     try {
73996       (arg1)->SetAxisAutoLockGradient(arg2);
73997     } catch (std::out_of_range& e) {
73998       {
73999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74000       };
74001     } catch (std::exception& e) {
74002       {
74003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74004       };
74005     } catch (...) {
74006       {
74007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74008       };
74009     }
74010   }
74011 }
74012
74013
74014 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
74015   float jresult ;
74016   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74017   float result;
74018
74019   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74020   {
74021     try {
74022       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
74023     } catch (std::out_of_range& e) {
74024       {
74025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74026       };
74027     } catch (std::exception& e) {
74028       {
74029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74030       };
74031     } catch (...) {
74032       {
74033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74034       };
74035     }
74036   }
74037   jresult = result;
74038   return jresult;
74039 }
74040
74041
74042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
74043   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74044   float arg2 ;
74045
74046   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74047   arg2 = (float)jarg2;
74048   {
74049     try {
74050       (arg1)->SetFrictionCoefficient(arg2);
74051     } catch (std::out_of_range& e) {
74052       {
74053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74054       };
74055     } catch (std::exception& e) {
74056       {
74057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74058       };
74059     } catch (...) {
74060       {
74061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74062       };
74063     }
74064   }
74065 }
74066
74067
74068 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
74069   float jresult ;
74070   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74071   float result;
74072
74073   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74074   {
74075     try {
74076       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
74077     } catch (std::out_of_range& e) {
74078       {
74079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74080       };
74081     } catch (std::exception& e) {
74082       {
74083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74084       };
74085     } catch (...) {
74086       {
74087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74088       };
74089     }
74090   }
74091   jresult = result;
74092   return jresult;
74093 }
74094
74095
74096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
74097   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74098   float arg2 ;
74099
74100   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74101   arg2 = (float)jarg2;
74102   {
74103     try {
74104       (arg1)->SetFlickSpeedCoefficient(arg2);
74105     } catch (std::out_of_range& e) {
74106       {
74107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74108       };
74109     } catch (std::exception& e) {
74110       {
74111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74112       };
74113     } catch (...) {
74114       {
74115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74116       };
74117     }
74118   }
74119 }
74120
74121
74122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
74123   void * jresult ;
74124   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74125   Dali::Vector2 result;
74126
74127   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74128   {
74129     try {
74130       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
74131     } catch (std::out_of_range& e) {
74132       {
74133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74134       };
74135     } catch (std::exception& e) {
74136       {
74137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74138       };
74139     } catch (...) {
74140       {
74141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74142       };
74143     }
74144   }
74145   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
74146   return jresult;
74147 }
74148
74149
74150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
74151   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74152   Dali::Vector2 *arg2 = 0 ;
74153
74154   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74155   arg2 = (Dali::Vector2 *)jarg2;
74156   if (!arg2) {
74157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74158     return ;
74159   }
74160   {
74161     try {
74162       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
74163     } catch (std::out_of_range& e) {
74164       {
74165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74166       };
74167     } catch (std::exception& e) {
74168       {
74169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74170       };
74171     } catch (...) {
74172       {
74173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74174       };
74175     }
74176   }
74177 }
74178
74179
74180 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
74181   float jresult ;
74182   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74183   float result;
74184
74185   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74186   {
74187     try {
74188       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
74189     } catch (std::out_of_range& e) {
74190       {
74191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74192       };
74193     } catch (std::exception& e) {
74194       {
74195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74196       };
74197     } catch (...) {
74198       {
74199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74200       };
74201     }
74202   }
74203   jresult = result;
74204   return jresult;
74205 }
74206
74207
74208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
74209   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74210   float arg2 ;
74211
74212   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74213   arg2 = (float)jarg2;
74214   {
74215     try {
74216       (arg1)->SetMinimumSpeedForFlick(arg2);
74217     } catch (std::out_of_range& e) {
74218       {
74219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74220       };
74221     } catch (std::exception& e) {
74222       {
74223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74224       };
74225     } catch (...) {
74226       {
74227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74228       };
74229     }
74230   }
74231 }
74232
74233
74234 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
74235   float jresult ;
74236   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74237   float result;
74238
74239   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74240   {
74241     try {
74242       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
74243     } catch (std::out_of_range& e) {
74244       {
74245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74246       };
74247     } catch (std::exception& e) {
74248       {
74249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74250       };
74251     } catch (...) {
74252       {
74253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74254       };
74255     }
74256   }
74257   jresult = result;
74258   return jresult;
74259 }
74260
74261
74262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
74263   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74264   float arg2 ;
74265
74266   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74267   arg2 = (float)jarg2;
74268   {
74269     try {
74270       (arg1)->SetMaxFlickSpeed(arg2);
74271     } catch (std::out_of_range& e) {
74272       {
74273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74274       };
74275     } catch (std::exception& e) {
74276       {
74277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74278       };
74279     } catch (...) {
74280       {
74281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74282       };
74283     }
74284   }
74285 }
74286
74287
74288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
74289   void * jresult ;
74290   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74291   Dali::Vector2 result;
74292
74293   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74294   {
74295     try {
74296       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
74297     } catch (std::out_of_range& e) {
74298       {
74299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74300       };
74301     } catch (std::exception& e) {
74302       {
74303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74304       };
74305     } catch (...) {
74306       {
74307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74308       };
74309     }
74310   }
74311   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
74312   return jresult;
74313 }
74314
74315
74316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
74317   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74318   Dali::Vector2 arg2 ;
74319   Dali::Vector2 *argp2 ;
74320
74321   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74322   argp2 = (Dali::Vector2 *)jarg2;
74323   if (!argp2) {
74324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
74325     return ;
74326   }
74327   arg2 = *argp2;
74328   {
74329     try {
74330       (arg1)->SetWheelScrollDistanceStep(arg2);
74331     } catch (std::out_of_range& e) {
74332       {
74333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74334       };
74335     } catch (std::exception& e) {
74336       {
74337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74338       };
74339     } catch (...) {
74340       {
74341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74342       };
74343     }
74344   }
74345 }
74346
74347
74348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
74349   void * jresult ;
74350   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74351   Dali::Vector2 result;
74352
74353   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74354   {
74355     try {
74356       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
74357     } catch (std::out_of_range& e) {
74358       {
74359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74360       };
74361     } catch (std::exception& e) {
74362       {
74363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74364       };
74365     } catch (...) {
74366       {
74367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74368       };
74369     }
74370   }
74371   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
74372   return jresult;
74373 }
74374
74375
74376 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
74377   unsigned int jresult ;
74378   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74379   unsigned int result;
74380
74381   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74382   {
74383     try {
74384       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
74385     } catch (std::out_of_range& e) {
74386       {
74387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74388       };
74389     } catch (std::exception& e) {
74390       {
74391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74392       };
74393     } catch (...) {
74394       {
74395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74396       };
74397     }
74398   }
74399   jresult = result;
74400   return jresult;
74401 }
74402
74403
74404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
74405   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74406   Dali::Vector2 *arg2 = 0 ;
74407
74408   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74409   arg2 = (Dali::Vector2 *)jarg2;
74410   if (!arg2) {
74411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74412     return ;
74413   }
74414   {
74415     try {
74416       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
74417     } catch (std::out_of_range& e) {
74418       {
74419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74420       };
74421     } catch (std::exception& e) {
74422       {
74423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74424       };
74425     } catch (...) {
74426       {
74427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74428       };
74429     }
74430   }
74431 }
74432
74433
74434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
74435   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74436   Dali::Vector2 *arg2 = 0 ;
74437   float arg3 ;
74438
74439   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74440   arg2 = (Dali::Vector2 *)jarg2;
74441   if (!arg2) {
74442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74443     return ;
74444   }
74445   arg3 = (float)jarg3;
74446   {
74447     try {
74448       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
74449     } catch (std::out_of_range& e) {
74450       {
74451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74452       };
74453     } catch (std::exception& e) {
74454       {
74455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74456       };
74457     } catch (...) {
74458       {
74459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74460       };
74461     }
74462   }
74463 }
74464
74465
74466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
74467   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74468   Dali::Vector2 *arg2 = 0 ;
74469   float arg3 ;
74470   Dali::AlphaFunction arg4 ;
74471   Dali::AlphaFunction *argp4 ;
74472
74473   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74474   arg2 = (Dali::Vector2 *)jarg2;
74475   if (!arg2) {
74476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74477     return ;
74478   }
74479   arg3 = (float)jarg3;
74480   argp4 = (Dali::AlphaFunction *)jarg4;
74481   if (!argp4) {
74482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74483     return ;
74484   }
74485   arg4 = *argp4;
74486   {
74487     try {
74488       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
74489     } catch (std::out_of_range& e) {
74490       {
74491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74492       };
74493     } catch (std::exception& e) {
74494       {
74495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74496       };
74497     } catch (...) {
74498       {
74499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74500       };
74501     }
74502   }
74503 }
74504
74505
74506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
74507   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74508   Dali::Vector2 *arg2 = 0 ;
74509   float arg3 ;
74510   Dali::Toolkit::DirectionBias arg4 ;
74511   Dali::Toolkit::DirectionBias arg5 ;
74512
74513   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74514   arg2 = (Dali::Vector2 *)jarg2;
74515   if (!arg2) {
74516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74517     return ;
74518   }
74519   arg3 = (float)jarg3;
74520   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
74521   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
74522   {
74523     try {
74524       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
74525     } catch (std::out_of_range& e) {
74526       {
74527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74528       };
74529     } catch (std::exception& e) {
74530       {
74531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74532       };
74533     } catch (...) {
74534       {
74535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74536       };
74537     }
74538   }
74539 }
74540
74541
74542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
74543   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74544   Dali::Vector2 *arg2 = 0 ;
74545   float arg3 ;
74546   Dali::AlphaFunction arg4 ;
74547   Dali::Toolkit::DirectionBias arg5 ;
74548   Dali::Toolkit::DirectionBias arg6 ;
74549   Dali::AlphaFunction *argp4 ;
74550
74551   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74552   arg2 = (Dali::Vector2 *)jarg2;
74553   if (!arg2) {
74554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74555     return ;
74556   }
74557   arg3 = (float)jarg3;
74558   argp4 = (Dali::AlphaFunction *)jarg4;
74559   if (!argp4) {
74560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74561     return ;
74562   }
74563   arg4 = *argp4;
74564   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
74565   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
74566   {
74567     try {
74568       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
74569     } catch (std::out_of_range& e) {
74570       {
74571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74572       };
74573     } catch (std::exception& e) {
74574       {
74575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74576       };
74577     } catch (...) {
74578       {
74579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74580       };
74581     }
74582   }
74583 }
74584
74585
74586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
74587   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74588   unsigned int arg2 ;
74589
74590   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74591   arg2 = (unsigned int)jarg2;
74592   {
74593     try {
74594       (arg1)->ScrollTo(arg2);
74595     } catch (std::out_of_range& e) {
74596       {
74597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74598       };
74599     } catch (std::exception& e) {
74600       {
74601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74602       };
74603     } catch (...) {
74604       {
74605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74606       };
74607     }
74608   }
74609 }
74610
74611
74612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
74613   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74614   unsigned int arg2 ;
74615   float arg3 ;
74616
74617   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74618   arg2 = (unsigned int)jarg2;
74619   arg3 = (float)jarg3;
74620   {
74621     try {
74622       (arg1)->ScrollTo(arg2,arg3);
74623     } catch (std::out_of_range& e) {
74624       {
74625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74626       };
74627     } catch (std::exception& e) {
74628       {
74629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74630       };
74631     } catch (...) {
74632       {
74633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74634       };
74635     }
74636   }
74637 }
74638
74639
74640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
74641   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74642   unsigned int arg2 ;
74643   float arg3 ;
74644   Dali::Toolkit::DirectionBias arg4 ;
74645
74646   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74647   arg2 = (unsigned int)jarg2;
74648   arg3 = (float)jarg3;
74649   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
74650   {
74651     try {
74652       (arg1)->ScrollTo(arg2,arg3,arg4);
74653     } catch (std::out_of_range& e) {
74654       {
74655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74656       };
74657     } catch (std::exception& e) {
74658       {
74659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74660       };
74661     } catch (...) {
74662       {
74663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74664       };
74665     }
74666   }
74667 }
74668
74669
74670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
74671   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74672   Dali::Actor *arg2 = 0 ;
74673
74674   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74675   arg2 = (Dali::Actor *)jarg2;
74676   if (!arg2) {
74677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
74678     return ;
74679   }
74680   {
74681     try {
74682       (arg1)->ScrollTo(*arg2);
74683     } catch (std::out_of_range& e) {
74684       {
74685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74686       };
74687     } catch (std::exception& e) {
74688       {
74689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74690       };
74691     } catch (...) {
74692       {
74693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74694       };
74695     }
74696   }
74697 }
74698
74699
74700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
74701   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74702   Dali::Actor *arg2 = 0 ;
74703   float arg3 ;
74704
74705   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74706   arg2 = (Dali::Actor *)jarg2;
74707   if (!arg2) {
74708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
74709     return ;
74710   }
74711   arg3 = (float)jarg3;
74712   {
74713     try {
74714       (arg1)->ScrollTo(*arg2,arg3);
74715     } catch (std::out_of_range& e) {
74716       {
74717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74718       };
74719     } catch (std::exception& e) {
74720       {
74721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74722       };
74723     } catch (...) {
74724       {
74725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74726       };
74727     }
74728   }
74729 }
74730
74731
74732 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
74733   unsigned int jresult ;
74734   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74735   bool result;
74736
74737   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74738   {
74739     try {
74740       result = (bool)(arg1)->ScrollToSnapPoint();
74741     } catch (std::out_of_range& e) {
74742       {
74743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74744       };
74745     } catch (std::exception& e) {
74746       {
74747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74748       };
74749     } catch (...) {
74750       {
74751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74752       };
74753     }
74754   }
74755   jresult = result;
74756   return jresult;
74757 }
74758
74759
74760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
74761   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74762   Dali::Constraint arg2 ;
74763   Dali::Constraint *argp2 ;
74764
74765   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74766   argp2 = (Dali::Constraint *)jarg2;
74767   if (!argp2) {
74768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
74769     return ;
74770   }
74771   arg2 = *argp2;
74772   {
74773     try {
74774       (arg1)->ApplyConstraintToChildren(arg2);
74775     } catch (std::out_of_range& e) {
74776       {
74777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74778       };
74779     } catch (std::exception& e) {
74780       {
74781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74782       };
74783     } catch (...) {
74784       {
74785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74786       };
74787     }
74788   }
74789 }
74790
74791
74792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
74793   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74794
74795   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74796   {
74797     try {
74798       (arg1)->RemoveConstraintsFromChildren();
74799     } catch (std::out_of_range& e) {
74800       {
74801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74802       };
74803     } catch (std::exception& e) {
74804       {
74805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74806       };
74807     } catch (...) {
74808       {
74809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74810       };
74811     }
74812   }
74813 }
74814
74815
74816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
74817   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74818   Dali::Toolkit::ScrollViewEffect arg2 ;
74819   Dali::Toolkit::ScrollViewEffect *argp2 ;
74820
74821   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74822   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
74823   if (!argp2) {
74824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
74825     return ;
74826   }
74827   arg2 = *argp2;
74828   {
74829     try {
74830       (arg1)->ApplyEffect(arg2);
74831     } catch (std::out_of_range& e) {
74832       {
74833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74834       };
74835     } catch (std::exception& e) {
74836       {
74837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74838       };
74839     } catch (...) {
74840       {
74841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74842       };
74843     }
74844   }
74845 }
74846
74847
74848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
74849   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74850   Dali::Toolkit::ScrollViewEffect arg2 ;
74851   Dali::Toolkit::ScrollViewEffect *argp2 ;
74852
74853   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74854   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
74855   if (!argp2) {
74856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
74857     return ;
74858   }
74859   arg2 = *argp2;
74860   {
74861     try {
74862       (arg1)->RemoveEffect(arg2);
74863     } catch (std::out_of_range& e) {
74864       {
74865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74866       };
74867     } catch (std::exception& e) {
74868       {
74869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74870       };
74871     } catch (...) {
74872       {
74873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74874       };
74875     }
74876   }
74877 }
74878
74879
74880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
74881   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74882
74883   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74884   {
74885     try {
74886       (arg1)->RemoveAllEffects();
74887     } catch (std::out_of_range& e) {
74888       {
74889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74890       };
74891     } catch (std::exception& e) {
74892       {
74893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74894       };
74895     } catch (...) {
74896       {
74897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74898       };
74899     }
74900   }
74901 }
74902
74903
74904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
74905   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74906   Dali::Actor arg2 ;
74907   Dali::Actor *argp2 ;
74908
74909   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74910   argp2 = (Dali::Actor *)jarg2;
74911   if (!argp2) {
74912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74913     return ;
74914   }
74915   arg2 = *argp2;
74916   {
74917     try {
74918       (arg1)->BindActor(arg2);
74919     } catch (std::out_of_range& e) {
74920       {
74921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74922       };
74923     } catch (std::exception& e) {
74924       {
74925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74926       };
74927     } catch (...) {
74928       {
74929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74930       };
74931     }
74932   }
74933 }
74934
74935
74936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
74937   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74938   Dali::Actor arg2 ;
74939   Dali::Actor *argp2 ;
74940
74941   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74942   argp2 = (Dali::Actor *)jarg2;
74943   if (!argp2) {
74944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74945     return ;
74946   }
74947   arg2 = *argp2;
74948   {
74949     try {
74950       (arg1)->UnbindActor(arg2);
74951     } catch (std::out_of_range& e) {
74952       {
74953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74954       };
74955     } catch (std::exception& e) {
74956       {
74957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74958       };
74959     } catch (...) {
74960       {
74961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74962       };
74963     }
74964   }
74965 }
74966
74967
74968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
74969   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74970   Dali::Radian arg2 ;
74971   Dali::Radian arg3 ;
74972   Dali::Radian *argp2 ;
74973   Dali::Radian *argp3 ;
74974
74975   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74976   argp2 = (Dali::Radian *)jarg2;
74977   if (!argp2) {
74978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
74979     return ;
74980   }
74981   arg2 = *argp2;
74982   argp3 = (Dali::Radian *)jarg3;
74983   if (!argp3) {
74984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
74985     return ;
74986   }
74987   arg3 = *argp3;
74988   {
74989     try {
74990       (arg1)->SetScrollingDirection(arg2,arg3);
74991     } catch (std::out_of_range& e) {
74992       {
74993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74994       };
74995     } catch (std::exception& e) {
74996       {
74997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74998       };
74999     } catch (...) {
75000       {
75001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75002       };
75003     }
75004   }
75005 }
75006
75007
75008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
75009   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75010   Dali::Radian arg2 ;
75011   Dali::Radian *argp2 ;
75012
75013   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75014   argp2 = (Dali::Radian *)jarg2;
75015   if (!argp2) {
75016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
75017     return ;
75018   }
75019   arg2 = *argp2;
75020   {
75021     try {
75022       (arg1)->SetScrollingDirection(arg2);
75023     } catch (std::out_of_range& e) {
75024       {
75025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75026       };
75027     } catch (std::exception& e) {
75028       {
75029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75030       };
75031     } catch (...) {
75032       {
75033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75034       };
75035     }
75036   }
75037 }
75038
75039
75040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
75041   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75042   Dali::Radian arg2 ;
75043   Dali::Radian *argp2 ;
75044
75045   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75046   argp2 = (Dali::Radian *)jarg2;
75047   if (!argp2) {
75048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
75049     return ;
75050   }
75051   arg2 = *argp2;
75052   {
75053     try {
75054       (arg1)->RemoveScrollingDirection(arg2);
75055     } catch (std::out_of_range& e) {
75056       {
75057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75058       };
75059     } catch (std::exception& e) {
75060       {
75061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75062       };
75063     } catch (...) {
75064       {
75065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75066       };
75067     }
75068   }
75069 }
75070
75071
75072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
75073   void * jresult ;
75074   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75075   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
75076
75077   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75078   {
75079     try {
75080       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
75081     } catch (std::out_of_range& e) {
75082       {
75083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75084       };
75085     } catch (std::exception& e) {
75086       {
75087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75088       };
75089     } catch (...) {
75090       {
75091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75092       };
75093     }
75094   }
75095   jresult = (void *)result;
75096   return jresult;
75097 }
75098
75099
75100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
75101   int jresult ;
75102   int result;
75103
75104   result = (int)Dali::Toolkit::TableView::Property::ROWS;
75105   jresult = (int)result;
75106   return jresult;
75107 }
75108
75109
75110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
75111   int jresult ;
75112   int result;
75113
75114   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
75115   jresult = (int)result;
75116   return jresult;
75117 }
75118
75119
75120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
75121   int jresult ;
75122   int result;
75123
75124   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
75125   jresult = (int)result;
75126   return jresult;
75127 }
75128
75129
75130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
75131   int jresult ;
75132   int result;
75133
75134   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
75135   jresult = (int)result;
75136   return jresult;
75137 }
75138
75139
75140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
75141   int jresult ;
75142   int result;
75143
75144   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
75145   jresult = (int)result;
75146   return jresult;
75147 }
75148
75149
75150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
75151   void * jresult ;
75152   Dali::Toolkit::TableView::Property *result = 0 ;
75153
75154   {
75155     try {
75156       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
75157     } catch (std::out_of_range& e) {
75158       {
75159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75160       };
75161     } catch (std::exception& e) {
75162       {
75163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75164       };
75165     } catch (...) {
75166       {
75167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75168       };
75169     }
75170   }
75171   jresult = (void *)result;
75172   return jresult;
75173 }
75174
75175
75176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
75177   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
75178
75179   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
75180   {
75181     try {
75182       delete arg1;
75183     } catch (std::out_of_range& e) {
75184       {
75185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75186       };
75187     } catch (std::exception& e) {
75188       {
75189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75190       };
75191     } catch (...) {
75192       {
75193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75194       };
75195     }
75196   }
75197 }
75198
75199
75200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
75201   int jresult ;
75202   int result;
75203
75204   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
75205   jresult = (int)result;
75206   return jresult;
75207 }
75208
75209
75210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
75211   int jresult ;
75212   int result;
75213
75214   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
75215   jresult = (int)result;
75216   return jresult;
75217 }
75218
75219
75220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
75221   int jresult ;
75222   int result;
75223
75224   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
75225   jresult = (int)result;
75226   return jresult;
75227 }
75228
75229
75230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
75231   int jresult ;
75232   int result;
75233
75234   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
75235   jresult = (int)result;
75236   return jresult;
75237 }
75238
75239
75240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
75241   int jresult ;
75242   int result;
75243
75244   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
75245   jresult = (int)result;
75246   return jresult;
75247 }
75248
75249
75250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
75251   void * jresult ;
75252   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
75253
75254   {
75255     try {
75256       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
75257     } catch (std::out_of_range& e) {
75258       {
75259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75260       };
75261     } catch (std::exception& e) {
75262       {
75263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75264       };
75265     } catch (...) {
75266       {
75267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75268       };
75269     }
75270   }
75271   jresult = (void *)result;
75272   return jresult;
75273 }
75274
75275
75276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
75277   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
75278
75279   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
75280   {
75281     try {
75282       delete arg1;
75283     } catch (std::out_of_range& e) {
75284       {
75285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75286       };
75287     } catch (std::exception& e) {
75288       {
75289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75290       };
75291     } catch (...) {
75292       {
75293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75294       };
75295     }
75296   }
75297 }
75298
75299
75300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
75301   void * jresult ;
75302   unsigned int arg1 ;
75303   unsigned int arg2 ;
75304   unsigned int arg3 ;
75305   unsigned int arg4 ;
75306   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75307
75308   arg1 = (unsigned int)jarg1;
75309   arg2 = (unsigned int)jarg2;
75310   arg3 = (unsigned int)jarg3;
75311   arg4 = (unsigned int)jarg4;
75312   {
75313     try {
75314       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
75315     } catch (std::out_of_range& e) {
75316       {
75317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75318       };
75319     } catch (std::exception& e) {
75320       {
75321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75322       };
75323     } catch (...) {
75324       {
75325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75326       };
75327     }
75328   }
75329   jresult = (void *)result;
75330   return jresult;
75331 }
75332
75333
75334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
75335   void * jresult ;
75336   unsigned int arg1 ;
75337   unsigned int arg2 ;
75338   unsigned int arg3 ;
75339   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75340
75341   arg1 = (unsigned int)jarg1;
75342   arg2 = (unsigned int)jarg2;
75343   arg3 = (unsigned int)jarg3;
75344   {
75345     try {
75346       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
75347     } catch (std::out_of_range& e) {
75348       {
75349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75350       };
75351     } catch (std::exception& e) {
75352       {
75353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75354       };
75355     } catch (...) {
75356       {
75357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75358       };
75359     }
75360   }
75361   jresult = (void *)result;
75362   return jresult;
75363 }
75364
75365
75366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
75367   void * jresult ;
75368   unsigned int arg1 ;
75369   unsigned int arg2 ;
75370   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75371
75372   arg1 = (unsigned int)jarg1;
75373   arg2 = (unsigned int)jarg2;
75374   {
75375     try {
75376       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
75377     } catch (std::out_of_range& e) {
75378       {
75379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75380       };
75381     } catch (std::exception& e) {
75382       {
75383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75384       };
75385     } catch (...) {
75386       {
75387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75388       };
75389     }
75390   }
75391   jresult = (void *)result;
75392   return jresult;
75393 }
75394
75395
75396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
75397   void * jresult ;
75398   unsigned int arg1 ;
75399   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75400
75401   arg1 = (unsigned int)jarg1;
75402   {
75403     try {
75404       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
75405     } catch (std::out_of_range& e) {
75406       {
75407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75408       };
75409     } catch (std::exception& e) {
75410       {
75411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75412       };
75413     } catch (...) {
75414       {
75415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75416       };
75417     }
75418   }
75419   jresult = (void *)result;
75420   return jresult;
75421 }
75422
75423
75424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
75425   void * jresult ;
75426   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75427
75428   {
75429     try {
75430       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
75431     } catch (std::out_of_range& e) {
75432       {
75433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75434       };
75435     } catch (std::exception& e) {
75436       {
75437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75438       };
75439     } catch (...) {
75440       {
75441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75442       };
75443     }
75444   }
75445   jresult = (void *)result;
75446   return jresult;
75447 }
75448
75449
75450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
75451   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75452   unsigned int arg2 ;
75453
75454   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75455   arg2 = (unsigned int)jarg2;
75456   if (arg1) (arg1)->rowIndex = arg2;
75457 }
75458
75459
75460 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
75461   unsigned int jresult ;
75462   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75463   unsigned int result;
75464
75465   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75466   result = (unsigned int) ((arg1)->rowIndex);
75467   jresult = result;
75468   return jresult;
75469 }
75470
75471
75472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
75473   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75474   unsigned int arg2 ;
75475
75476   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75477   arg2 = (unsigned int)jarg2;
75478   if (arg1) (arg1)->columnIndex = arg2;
75479 }
75480
75481
75482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
75483   unsigned int jresult ;
75484   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75485   unsigned int result;
75486
75487   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75488   result = (unsigned int) ((arg1)->columnIndex);
75489   jresult = result;
75490   return jresult;
75491 }
75492
75493
75494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
75495   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75496   unsigned int arg2 ;
75497
75498   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75499   arg2 = (unsigned int)jarg2;
75500   if (arg1) (arg1)->rowSpan = arg2;
75501 }
75502
75503
75504 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
75505   unsigned int jresult ;
75506   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75507   unsigned int result;
75508
75509   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75510   result = (unsigned int) ((arg1)->rowSpan);
75511   jresult = result;
75512   return jresult;
75513 }
75514
75515
75516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
75517   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75518   unsigned int arg2 ;
75519
75520   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75521   arg2 = (unsigned int)jarg2;
75522   if (arg1) (arg1)->columnSpan = arg2;
75523 }
75524
75525
75526 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
75527   unsigned int jresult ;
75528   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75529   unsigned int result;
75530
75531   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75532   result = (unsigned int) ((arg1)->columnSpan);
75533   jresult = result;
75534   return jresult;
75535 }
75536
75537
75538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
75539   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75540
75541   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75542   {
75543     try {
75544       delete arg1;
75545     } catch (std::out_of_range& e) {
75546       {
75547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75548       };
75549     } catch (std::exception& e) {
75550       {
75551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75552       };
75553     } catch (...) {
75554       {
75555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75556       };
75557     }
75558   }
75559 }
75560
75561
75562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
75563   void * jresult ;
75564   Dali::Toolkit::TableView *result = 0 ;
75565
75566   {
75567     try {
75568       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
75569     } catch (std::out_of_range& e) {
75570       {
75571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75572       };
75573     } catch (std::exception& e) {
75574       {
75575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75576       };
75577     } catch (...) {
75578       {
75579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75580       };
75581     }
75582   }
75583   jresult = (void *)result;
75584   return jresult;
75585 }
75586
75587
75588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
75589   void * jresult ;
75590   Dali::Toolkit::TableView *arg1 = 0 ;
75591   Dali::Toolkit::TableView *result = 0 ;
75592
75593   arg1 = (Dali::Toolkit::TableView *)jarg1;
75594   if (!arg1) {
75595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
75596     return 0;
75597   }
75598   {
75599     try {
75600       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
75601     } catch (std::out_of_range& e) {
75602       {
75603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75604       };
75605     } catch (std::exception& e) {
75606       {
75607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75608       };
75609     } catch (...) {
75610       {
75611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75612       };
75613     }
75614   }
75615   jresult = (void *)result;
75616   return jresult;
75617 }
75618
75619
75620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
75621   void * jresult ;
75622   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75623   Dali::Toolkit::TableView *arg2 = 0 ;
75624   Dali::Toolkit::TableView *result = 0 ;
75625
75626   arg1 = (Dali::Toolkit::TableView *)jarg1;
75627   arg2 = (Dali::Toolkit::TableView *)jarg2;
75628   if (!arg2) {
75629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
75630     return 0;
75631   }
75632   {
75633     try {
75634       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
75635     } catch (std::out_of_range& e) {
75636       {
75637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75638       };
75639     } catch (std::exception& e) {
75640       {
75641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75642       };
75643     } catch (...) {
75644       {
75645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75646       };
75647     }
75648   }
75649   jresult = (void *)result;
75650   return jresult;
75651 }
75652
75653
75654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
75655   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75656
75657   arg1 = (Dali::Toolkit::TableView *)jarg1;
75658   {
75659     try {
75660       delete arg1;
75661     } catch (std::out_of_range& e) {
75662       {
75663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75664       };
75665     } catch (std::exception& e) {
75666       {
75667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75668       };
75669     } catch (...) {
75670       {
75671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75672       };
75673     }
75674   }
75675 }
75676
75677
75678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
75679   void * jresult ;
75680   unsigned int arg1 ;
75681   unsigned int arg2 ;
75682   Dali::Toolkit::TableView result;
75683
75684   arg1 = (unsigned int)jarg1;
75685   arg2 = (unsigned int)jarg2;
75686   {
75687     try {
75688       result = Dali::Toolkit::TableView::New(arg1,arg2);
75689     } catch (std::out_of_range& e) {
75690       {
75691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75692       };
75693     } catch (std::exception& e) {
75694       {
75695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75696       };
75697     } catch (...) {
75698       {
75699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75700       };
75701     }
75702   }
75703   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
75704   return jresult;
75705 }
75706
75707
75708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
75709   void * jresult ;
75710   Dali::BaseHandle arg1 ;
75711   Dali::BaseHandle *argp1 ;
75712   Dali::Toolkit::TableView result;
75713
75714   argp1 = (Dali::BaseHandle *)jarg1;
75715   if (!argp1) {
75716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75717     return 0;
75718   }
75719   arg1 = *argp1;
75720   {
75721     try {
75722       result = Dali::Toolkit::TableView::DownCast(arg1);
75723     } catch (std::out_of_range& e) {
75724       {
75725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75726       };
75727     } catch (std::exception& e) {
75728       {
75729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75730       };
75731     } catch (...) {
75732       {
75733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75734       };
75735     }
75736   }
75737   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
75738   return jresult;
75739 }
75740
75741
75742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
75743   unsigned int jresult ;
75744   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75745   Dali::Actor arg2 ;
75746   Dali::Toolkit::TableView::CellPosition arg3 ;
75747   Dali::Actor *argp2 ;
75748   Dali::Toolkit::TableView::CellPosition *argp3 ;
75749   bool result;
75750
75751   arg1 = (Dali::Toolkit::TableView *)jarg1;
75752   argp2 = (Dali::Actor *)jarg2;
75753   if (!argp2) {
75754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75755     return 0;
75756   }
75757   arg2 = *argp2;
75758   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
75759   if (!argp3) {
75760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
75761     return 0;
75762   }
75763   arg3 = *argp3;
75764   {
75765     try {
75766       result = (bool)(arg1)->AddChild(arg2,arg3);
75767     } catch (std::out_of_range& e) {
75768       {
75769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75770       };
75771     } catch (std::exception& e) {
75772       {
75773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75774       };
75775     } catch (...) {
75776       {
75777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75778       };
75779     }
75780   }
75781   jresult = result;
75782   return jresult;
75783 }
75784
75785
75786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
75787   void * jresult ;
75788   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75789   Dali::Toolkit::TableView::CellPosition arg2 ;
75790   Dali::Toolkit::TableView::CellPosition *argp2 ;
75791   Dali::Actor result;
75792
75793   arg1 = (Dali::Toolkit::TableView *)jarg1;
75794   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
75795   if (!argp2) {
75796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
75797     return 0;
75798   }
75799   arg2 = *argp2;
75800   {
75801     try {
75802       result = (arg1)->GetChildAt(arg2);
75803     } catch (std::out_of_range& e) {
75804       {
75805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75806       };
75807     } catch (std::exception& e) {
75808       {
75809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75810       };
75811     } catch (...) {
75812       {
75813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75814       };
75815     }
75816   }
75817   jresult = new Dali::Actor((const Dali::Actor &)result);
75818   return jresult;
75819 }
75820
75821
75822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
75823   void * jresult ;
75824   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75825   Dali::Toolkit::TableView::CellPosition arg2 ;
75826   Dali::Toolkit::TableView::CellPosition *argp2 ;
75827   Dali::Actor result;
75828
75829   arg1 = (Dali::Toolkit::TableView *)jarg1;
75830   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
75831   if (!argp2) {
75832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
75833     return 0;
75834   }
75835   arg2 = *argp2;
75836   {
75837     try {
75838       result = (arg1)->RemoveChildAt(arg2);
75839     } catch (std::out_of_range& e) {
75840       {
75841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75842       };
75843     } catch (std::exception& e) {
75844       {
75845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75846       };
75847     } catch (...) {
75848       {
75849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75850       };
75851     }
75852   }
75853   jresult = new Dali::Actor((const Dali::Actor &)result);
75854   return jresult;
75855 }
75856
75857
75858 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
75859   unsigned int jresult ;
75860   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75861   Dali::Actor arg2 ;
75862   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
75863   Dali::Actor *argp2 ;
75864   bool result;
75865
75866   arg1 = (Dali::Toolkit::TableView *)jarg1;
75867   argp2 = (Dali::Actor *)jarg2;
75868   if (!argp2) {
75869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75870     return 0;
75871   }
75872   arg2 = *argp2;
75873   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
75874   if (!arg3) {
75875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
75876     return 0;
75877   }
75878   {
75879     try {
75880       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
75881     } catch (std::out_of_range& e) {
75882       {
75883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75884       };
75885     } catch (std::exception& e) {
75886       {
75887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75888       };
75889     } catch (...) {
75890       {
75891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75892       };
75893     }
75894   }
75895   jresult = result;
75896   return jresult;
75897 }
75898
75899
75900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
75901   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75902   unsigned int arg2 ;
75903
75904   arg1 = (Dali::Toolkit::TableView *)jarg1;
75905   arg2 = (unsigned int)jarg2;
75906   {
75907     try {
75908       (arg1)->InsertRow(arg2);
75909     } catch (std::out_of_range& e) {
75910       {
75911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75912       };
75913     } catch (std::exception& e) {
75914       {
75915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75916       };
75917     } catch (...) {
75918       {
75919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75920       };
75921     }
75922   }
75923 }
75924
75925
75926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
75927   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75928   unsigned int arg2 ;
75929
75930   arg1 = (Dali::Toolkit::TableView *)jarg1;
75931   arg2 = (unsigned int)jarg2;
75932   {
75933     try {
75934       (arg1)->DeleteRow(arg2);
75935     } catch (std::out_of_range& e) {
75936       {
75937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75938       };
75939     } catch (std::exception& e) {
75940       {
75941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75942       };
75943     } catch (...) {
75944       {
75945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75946       };
75947     }
75948   }
75949 }
75950
75951
75952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
75953   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75954   unsigned int arg2 ;
75955   std::vector< Dali::Actor > *arg3 = 0 ;
75956
75957   arg1 = (Dali::Toolkit::TableView *)jarg1;
75958   arg2 = (unsigned int)jarg2;
75959   arg3 = (std::vector< Dali::Actor > *)jarg3;
75960   if (!arg3) {
75961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
75962     return ;
75963   }
75964   {
75965     try {
75966       (arg1)->DeleteRow(arg2,*arg3);
75967     } catch (std::out_of_range& e) {
75968       {
75969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75970       };
75971     } catch (std::exception& e) {
75972       {
75973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75974       };
75975     } catch (...) {
75976       {
75977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75978       };
75979     }
75980   }
75981 }
75982
75983
75984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
75985   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75986   unsigned int arg2 ;
75987
75988   arg1 = (Dali::Toolkit::TableView *)jarg1;
75989   arg2 = (unsigned int)jarg2;
75990   {
75991     try {
75992       (arg1)->InsertColumn(arg2);
75993     } catch (std::out_of_range& e) {
75994       {
75995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75996       };
75997     } catch (std::exception& e) {
75998       {
75999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76000       };
76001     } catch (...) {
76002       {
76003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76004       };
76005     }
76006   }
76007 }
76008
76009
76010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
76011   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76012   unsigned int arg2 ;
76013
76014   arg1 = (Dali::Toolkit::TableView *)jarg1;
76015   arg2 = (unsigned int)jarg2;
76016   {
76017     try {
76018       (arg1)->DeleteColumn(arg2);
76019     } catch (std::out_of_range& e) {
76020       {
76021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76022       };
76023     } catch (std::exception& e) {
76024       {
76025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76026       };
76027     } catch (...) {
76028       {
76029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76030       };
76031     }
76032   }
76033 }
76034
76035
76036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
76037   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76038   unsigned int arg2 ;
76039   std::vector< Dali::Actor > *arg3 = 0 ;
76040
76041   arg1 = (Dali::Toolkit::TableView *)jarg1;
76042   arg2 = (unsigned int)jarg2;
76043   arg3 = (std::vector< Dali::Actor > *)jarg3;
76044   if (!arg3) {
76045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
76046     return ;
76047   }
76048   {
76049     try {
76050       (arg1)->DeleteColumn(arg2,*arg3);
76051     } catch (std::out_of_range& e) {
76052       {
76053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76054       };
76055     } catch (std::exception& e) {
76056       {
76057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76058       };
76059     } catch (...) {
76060       {
76061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76062       };
76063     }
76064   }
76065 }
76066
76067
76068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
76069   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76070   unsigned int arg2 ;
76071   unsigned int arg3 ;
76072
76073   arg1 = (Dali::Toolkit::TableView *)jarg1;
76074   arg2 = (unsigned int)jarg2;
76075   arg3 = (unsigned int)jarg3;
76076   {
76077     try {
76078       (arg1)->Resize(arg2,arg3);
76079     } catch (std::out_of_range& e) {
76080       {
76081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76082       };
76083     } catch (std::exception& e) {
76084       {
76085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76086       };
76087     } catch (...) {
76088       {
76089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76090       };
76091     }
76092   }
76093 }
76094
76095
76096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
76097   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76098   unsigned int arg2 ;
76099   unsigned int arg3 ;
76100   std::vector< Dali::Actor > *arg4 = 0 ;
76101
76102   arg1 = (Dali::Toolkit::TableView *)jarg1;
76103   arg2 = (unsigned int)jarg2;
76104   arg3 = (unsigned int)jarg3;
76105   arg4 = (std::vector< Dali::Actor > *)jarg4;
76106   if (!arg4) {
76107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
76108     return ;
76109   }
76110   {
76111     try {
76112       (arg1)->Resize(arg2,arg3,*arg4);
76113     } catch (std::out_of_range& e) {
76114       {
76115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76116       };
76117     } catch (std::exception& e) {
76118       {
76119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76120       };
76121     } catch (...) {
76122       {
76123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76124       };
76125     }
76126   }
76127 }
76128
76129
76130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
76131   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76132   Dali::Size arg2 ;
76133   Dali::Size *argp2 ;
76134
76135   arg1 = (Dali::Toolkit::TableView *)jarg1;
76136   argp2 = (Dali::Size *)jarg2;
76137   if (!argp2) {
76138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
76139     return ;
76140   }
76141   arg2 = *argp2;
76142   {
76143     try {
76144       (arg1)->SetCellPadding(arg2);
76145     } catch (std::out_of_range& e) {
76146       {
76147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76148       };
76149     } catch (std::exception& e) {
76150       {
76151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76152       };
76153     } catch (...) {
76154       {
76155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76156       };
76157     }
76158   }
76159 }
76160
76161
76162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
76163   void * jresult ;
76164   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76165   Dali::Size result;
76166
76167   arg1 = (Dali::Toolkit::TableView *)jarg1;
76168   {
76169     try {
76170       result = (arg1)->GetCellPadding();
76171     } catch (std::out_of_range& e) {
76172       {
76173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76174       };
76175     } catch (std::exception& e) {
76176       {
76177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76178       };
76179     } catch (...) {
76180       {
76181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76182       };
76183     }
76184   }
76185   jresult = new Dali::Size((const Dali::Size &)result);
76186   return jresult;
76187 }
76188
76189
76190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
76191   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76192   unsigned int arg2 ;
76193
76194   arg1 = (Dali::Toolkit::TableView *)jarg1;
76195   arg2 = (unsigned int)jarg2;
76196   {
76197     try {
76198       (arg1)->SetFitHeight(arg2);
76199     } catch (std::out_of_range& e) {
76200       {
76201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76202       };
76203     } catch (std::exception& e) {
76204       {
76205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76206       };
76207     } catch (...) {
76208       {
76209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76210       };
76211     }
76212   }
76213 }
76214
76215
76216 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
76217   unsigned int jresult ;
76218   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76219   unsigned int arg2 ;
76220   bool result;
76221
76222   arg1 = (Dali::Toolkit::TableView *)jarg1;
76223   arg2 = (unsigned int)jarg2;
76224   {
76225     try {
76226       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
76227     } catch (std::out_of_range& e) {
76228       {
76229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76230       };
76231     } catch (std::exception& e) {
76232       {
76233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76234       };
76235     } catch (...) {
76236       {
76237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76238       };
76239     }
76240   }
76241   jresult = result;
76242   return jresult;
76243 }
76244
76245
76246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
76247   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76248   unsigned int arg2 ;
76249
76250   arg1 = (Dali::Toolkit::TableView *)jarg1;
76251   arg2 = (unsigned int)jarg2;
76252   {
76253     try {
76254       (arg1)->SetFitWidth(arg2);
76255     } catch (std::out_of_range& e) {
76256       {
76257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76258       };
76259     } catch (std::exception& e) {
76260       {
76261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76262       };
76263     } catch (...) {
76264       {
76265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76266       };
76267     }
76268   }
76269 }
76270
76271
76272 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
76273   unsigned int jresult ;
76274   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76275   unsigned int arg2 ;
76276   bool result;
76277
76278   arg1 = (Dali::Toolkit::TableView *)jarg1;
76279   arg2 = (unsigned int)jarg2;
76280   {
76281     try {
76282       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
76283     } catch (std::out_of_range& e) {
76284       {
76285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76286       };
76287     } catch (std::exception& e) {
76288       {
76289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76290       };
76291     } catch (...) {
76292       {
76293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76294       };
76295     }
76296   }
76297   jresult = result;
76298   return jresult;
76299 }
76300
76301
76302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
76303   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76304   unsigned int arg2 ;
76305   float arg3 ;
76306
76307   arg1 = (Dali::Toolkit::TableView *)jarg1;
76308   arg2 = (unsigned int)jarg2;
76309   arg3 = (float)jarg3;
76310   {
76311     try {
76312       (arg1)->SetFixedHeight(arg2,arg3);
76313     } catch (std::out_of_range& e) {
76314       {
76315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76316       };
76317     } catch (std::exception& e) {
76318       {
76319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76320       };
76321     } catch (...) {
76322       {
76323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76324       };
76325     }
76326   }
76327 }
76328
76329
76330 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
76331   float jresult ;
76332   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76333   unsigned int arg2 ;
76334   float result;
76335
76336   arg1 = (Dali::Toolkit::TableView *)jarg1;
76337   arg2 = (unsigned int)jarg2;
76338   {
76339     try {
76340       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
76341     } catch (std::out_of_range& e) {
76342       {
76343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76344       };
76345     } catch (std::exception& e) {
76346       {
76347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76348       };
76349     } catch (...) {
76350       {
76351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76352       };
76353     }
76354   }
76355   jresult = result;
76356   return jresult;
76357 }
76358
76359
76360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
76361   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76362   unsigned int arg2 ;
76363   float arg3 ;
76364
76365   arg1 = (Dali::Toolkit::TableView *)jarg1;
76366   arg2 = (unsigned int)jarg2;
76367   arg3 = (float)jarg3;
76368   {
76369     try {
76370       (arg1)->SetRelativeHeight(arg2,arg3);
76371     } catch (std::out_of_range& e) {
76372       {
76373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76374       };
76375     } catch (std::exception& e) {
76376       {
76377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76378       };
76379     } catch (...) {
76380       {
76381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76382       };
76383     }
76384   }
76385 }
76386
76387
76388 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
76389   float jresult ;
76390   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76391   unsigned int arg2 ;
76392   float result;
76393
76394   arg1 = (Dali::Toolkit::TableView *)jarg1;
76395   arg2 = (unsigned int)jarg2;
76396   {
76397     try {
76398       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
76399     } catch (std::out_of_range& e) {
76400       {
76401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76402       };
76403     } catch (std::exception& e) {
76404       {
76405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76406       };
76407     } catch (...) {
76408       {
76409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76410       };
76411     }
76412   }
76413   jresult = result;
76414   return jresult;
76415 }
76416
76417
76418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
76419   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76420   unsigned int arg2 ;
76421   float arg3 ;
76422
76423   arg1 = (Dali::Toolkit::TableView *)jarg1;
76424   arg2 = (unsigned int)jarg2;
76425   arg3 = (float)jarg3;
76426   {
76427     try {
76428       (arg1)->SetFixedWidth(arg2,arg3);
76429     } catch (std::out_of_range& e) {
76430       {
76431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76432       };
76433     } catch (std::exception& e) {
76434       {
76435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76436       };
76437     } catch (...) {
76438       {
76439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76440       };
76441     }
76442   }
76443 }
76444
76445
76446 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
76447   float jresult ;
76448   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76449   unsigned int arg2 ;
76450   float result;
76451
76452   arg1 = (Dali::Toolkit::TableView *)jarg1;
76453   arg2 = (unsigned int)jarg2;
76454   {
76455     try {
76456       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
76457     } catch (std::out_of_range& e) {
76458       {
76459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76460       };
76461     } catch (std::exception& e) {
76462       {
76463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76464       };
76465     } catch (...) {
76466       {
76467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76468       };
76469     }
76470   }
76471   jresult = result;
76472   return jresult;
76473 }
76474
76475
76476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
76477   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76478   unsigned int arg2 ;
76479   float arg3 ;
76480
76481   arg1 = (Dali::Toolkit::TableView *)jarg1;
76482   arg2 = (unsigned int)jarg2;
76483   arg3 = (float)jarg3;
76484   {
76485     try {
76486       (arg1)->SetRelativeWidth(arg2,arg3);
76487     } catch (std::out_of_range& e) {
76488       {
76489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76490       };
76491     } catch (std::exception& e) {
76492       {
76493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76494       };
76495     } catch (...) {
76496       {
76497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76498       };
76499     }
76500   }
76501 }
76502
76503
76504 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
76505   float jresult ;
76506   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76507   unsigned int arg2 ;
76508   float result;
76509
76510   arg1 = (Dali::Toolkit::TableView *)jarg1;
76511   arg2 = (unsigned int)jarg2;
76512   {
76513     try {
76514       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
76515     } catch (std::out_of_range& e) {
76516       {
76517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76518       };
76519     } catch (std::exception& e) {
76520       {
76521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76522       };
76523     } catch (...) {
76524       {
76525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76526       };
76527     }
76528   }
76529   jresult = result;
76530   return jresult;
76531 }
76532
76533
76534 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
76535   unsigned int jresult ;
76536   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76537   unsigned int result;
76538
76539   arg1 = (Dali::Toolkit::TableView *)jarg1;
76540   {
76541     try {
76542       result = (unsigned int)(arg1)->GetRows();
76543     } catch (std::out_of_range& e) {
76544       {
76545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76546       };
76547     } catch (std::exception& e) {
76548       {
76549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76550       };
76551     } catch (...) {
76552       {
76553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76554       };
76555     }
76556   }
76557   jresult = result;
76558   return jresult;
76559 }
76560
76561
76562 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
76563   unsigned int jresult ;
76564   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76565   unsigned int result;
76566
76567   arg1 = (Dali::Toolkit::TableView *)jarg1;
76568   {
76569     try {
76570       result = (unsigned int)(arg1)->GetColumns();
76571     } catch (std::out_of_range& e) {
76572       {
76573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76574       };
76575     } catch (std::exception& e) {
76576       {
76577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76578       };
76579     } catch (...) {
76580       {
76581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76582       };
76583     }
76584   }
76585   jresult = result;
76586   return jresult;
76587 }
76588
76589
76590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
76591   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76592   Dali::Toolkit::TableView::CellPosition arg2 ;
76593   Dali::HorizontalAlignment::Type arg3 ;
76594   Dali::VerticalAlignment::Type arg4 ;
76595   Dali::Toolkit::TableView::CellPosition *argp2 ;
76596
76597   arg1 = (Dali::Toolkit::TableView *)jarg1;
76598   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
76599   if (!argp2) {
76600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76601     return ;
76602   }
76603   arg2 = *argp2;
76604   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
76605   arg4 = (Dali::VerticalAlignment::Type)jarg4;
76606   {
76607     try {
76608       (arg1)->SetCellAlignment(arg2,arg3,arg4);
76609     } catch (std::out_of_range& e) {
76610       {
76611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76612       };
76613     } catch (std::exception& e) {
76614       {
76615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76616       };
76617     } catch (...) {
76618       {
76619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76620       };
76621     }
76622   }
76623 }
76624
76625
76626 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
76627   unsigned int jresult ;
76628   unsigned int result;
76629
76630   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
76631   jresult = result;
76632   return jresult;
76633 }
76634
76635
76636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_RENDERING_BACKEND_get() {
76637   int jresult ;
76638   int result;
76639
76640   result = (int)Dali::Toolkit::TextEditor::Property::RENDERING_BACKEND;
76641   jresult = (int)result;
76642   return jresult;
76643 }
76644
76645
76646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_get() {
76647   int jresult ;
76648   int result;
76649
76650   result = (int)Dali::Toolkit::TextEditor::Property::TEXT;
76651   jresult = (int)result;
76652   return jresult;
76653 }
76654
76655
76656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_COLOR_get() {
76657   int jresult ;
76658   int result;
76659
76660   result = (int)Dali::Toolkit::TextEditor::Property::TEXT_COLOR;
76661   jresult = (int)result;
76662   return jresult;
76663 }
76664
76665
76666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_FAMILY_get() {
76667   int jresult ;
76668   int result;
76669
76670   result = (int)Dali::Toolkit::TextEditor::Property::FONT_FAMILY;
76671   jresult = (int)result;
76672   return jresult;
76673 }
76674
76675
76676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_STYLE_get() {
76677   int jresult ;
76678   int result;
76679
76680   result = (int)Dali::Toolkit::TextEditor::Property::FONT_STYLE;
76681   jresult = (int)result;
76682   return jresult;
76683 }
76684
76685
76686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_POINT_SIZE_get() {
76687   int jresult ;
76688   int result;
76689
76690   result = (int)Dali::Toolkit::TextEditor::Property::POINT_SIZE;
76691   jresult = (int)result;
76692   return jresult;
76693 }
76694
76695
76696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_HORIZONTAL_ALIGNMENT_get() {
76697   int jresult ;
76698   int result;
76699
76700   result = (int)Dali::Toolkit::TextEditor::Property::HORIZONTAL_ALIGNMENT;
76701   jresult = (int)result;
76702   return jresult;
76703 }
76704
76705
76706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_THRESHOLD_get() {
76707   int jresult ;
76708   int result;
76709
76710   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_THRESHOLD;
76711   jresult = (int)result;
76712   return jresult;
76713 }
76714
76715
76716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_SPEED_get() {
76717   int jresult ;
76718   int result;
76719
76720   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_SPEED;
76721   jresult = (int)result;
76722   return jresult;
76723 }
76724
76725
76726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_PRIMARY_CURSOR_COLOR_get() {
76727   int jresult ;
76728   int result;
76729
76730   result = (int)Dali::Toolkit::TextEditor::Property::PRIMARY_CURSOR_COLOR;
76731   jresult = (int)result;
76732   return jresult;
76733 }
76734
76735
76736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SECONDARY_CURSOR_COLOR_get() {
76737   int jresult ;
76738   int result;
76739
76740   result = (int)Dali::Toolkit::TextEditor::Property::SECONDARY_CURSOR_COLOR;
76741   jresult = (int)result;
76742   return jresult;
76743 }
76744
76745
76746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_CURSOR_BLINK_get() {
76747   int jresult ;
76748   int result;
76749
76750   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_CURSOR_BLINK;
76751   jresult = (int)result;
76752   return jresult;
76753 }
76754
76755
76756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_INTERVAL_get() {
76757   int jresult ;
76758   int result;
76759
76760   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_INTERVAL;
76761   jresult = (int)result;
76762   return jresult;
76763 }
76764
76765
76766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_DURATION_get() {
76767   int jresult ;
76768   int result;
76769
76770   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_DURATION;
76771   jresult = (int)result;
76772   return jresult;
76773 }
76774
76775
76776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_WIDTH_get() {
76777   int jresult ;
76778   int result;
76779
76780   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_WIDTH;
76781   jresult = (int)result;
76782   return jresult;
76783 }
76784
76785
76786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_IMAGE_get() {
76787   int jresult ;
76788   int result;
76789
76790   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_IMAGE;
76791   jresult = (int)result;
76792   return jresult;
76793 }
76794
76795
76796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
76797   int jresult ;
76798   int result;
76799
76800   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_PRESSED_IMAGE;
76801   jresult = (int)result;
76802   return jresult;
76803 }
76804
76805
76806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
76807   int jresult ;
76808   int result;
76809
76810   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_LEFT;
76811   jresult = (int)result;
76812   return jresult;
76813 }
76814
76815
76816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
76817   int jresult ;
76818   int result;
76819
76820   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_RIGHT;
76821   jresult = (int)result;
76822   return jresult;
76823 }
76824
76825
76826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
76827   int jresult ;
76828   int result;
76829
76830   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
76831   jresult = (int)result;
76832   return jresult;
76833 }
76834
76835
76836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
76837   int jresult ;
76838   int result;
76839
76840   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
76841   jresult = (int)result;
76842   return jresult;
76843 }
76844
76845
76846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
76847   int jresult ;
76848   int result;
76849
76850   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
76851   jresult = (int)result;
76852   return jresult;
76853 }
76854
76855
76856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
76857   int jresult ;
76858   int result;
76859
76860   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
76861   jresult = (int)result;
76862   return jresult;
76863 }
76864
76865
76866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HIGHLIGHT_COLOR_get() {
76867   int jresult ;
76868   int result;
76869
76870   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HIGHLIGHT_COLOR;
76871   jresult = (int)result;
76872   return jresult;
76873 }
76874
76875
76876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_DECORATION_BOUNDING_BOX_get() {
76877   int jresult ;
76878   int result;
76879
76880   result = (int)Dali::Toolkit::TextEditor::Property::DECORATION_BOUNDING_BOX;
76881   jresult = (int)result;
76882   return jresult;
76883 }
76884
76885
76886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_MARKUP_get() {
76887   int jresult ;
76888   int result;
76889
76890   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_MARKUP;
76891   jresult = (int)result;
76892   return jresult;
76893 }
76894
76895
76896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_COLOR_get() {
76897   int jresult ;
76898   int result;
76899
76900   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_COLOR;
76901   jresult = (int)result;
76902   return jresult;
76903 }
76904
76905
76906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_FAMILY_get() {
76907   int jresult ;
76908   int result;
76909
76910   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_FAMILY;
76911   jresult = (int)result;
76912   return jresult;
76913 }
76914
76915
76916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_STYLE_get() {
76917   int jresult ;
76918   int result;
76919
76920   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_STYLE;
76921   jresult = (int)result;
76922   return jresult;
76923 }
76924
76925
76926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_POINT_SIZE_get() {
76927   int jresult ;
76928   int result;
76929
76930   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_POINT_SIZE;
76931   jresult = (int)result;
76932   return jresult;
76933 }
76934
76935
76936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_LINE_SPACING_get() {
76937   int jresult ;
76938   int result;
76939
76940   result = (int)Dali::Toolkit::TextEditor::Property::LINE_SPACING;
76941   jresult = (int)result;
76942   return jresult;
76943 }
76944
76945
76946 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_LINE_SPACING_get() {
76947   int jresult ;
76948   int result;
76949
76950   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_LINE_SPACING;
76951   jresult = (int)result;
76952   return jresult;
76953 }
76954
76955
76956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_UNDERLINE_get() {
76957   int jresult ;
76958   int result;
76959
76960   result = (int)Dali::Toolkit::TextEditor::Property::UNDERLINE;
76961   jresult = (int)result;
76962   return jresult;
76963 }
76964
76965
76966 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_UNDERLINE_get() {
76967   int jresult ;
76968   int result;
76969
76970   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_UNDERLINE;
76971   jresult = (int)result;
76972   return jresult;
76973 }
76974
76975
76976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SHADOW_get() {
76977   int jresult ;
76978   int result;
76979
76980   result = (int)Dali::Toolkit::TextEditor::Property::SHADOW;
76981   jresult = (int)result;
76982   return jresult;
76983 }
76984
76985
76986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_SHADOW_get() {
76987   int jresult ;
76988   int result;
76989
76990   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_SHADOW;
76991   jresult = (int)result;
76992   return jresult;
76993 }
76994
76995
76996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_EMBOSS_get() {
76997   int jresult ;
76998   int result;
76999
77000   result = (int)Dali::Toolkit::TextEditor::Property::EMBOSS;
77001   jresult = (int)result;
77002   return jresult;
77003 }
77004
77005
77006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_EMBOSS_get() {
77007   int jresult ;
77008   int result;
77009
77010   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_EMBOSS;
77011   jresult = (int)result;
77012   return jresult;
77013 }
77014
77015
77016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_OUTLINE_get() {
77017   int jresult ;
77018   int result;
77019
77020   result = (int)Dali::Toolkit::TextEditor::Property::OUTLINE;
77021   jresult = (int)result;
77022   return jresult;
77023 }
77024
77025
77026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_OUTLINE_get() {
77027   int jresult ;
77028   int result;
77029
77030   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_OUTLINE;
77031   jresult = (int)result;
77032   return jresult;
77033 }
77034
77035
77036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_Property() {
77037   void * jresult ;
77038   Dali::Toolkit::TextEditor::Property *result = 0 ;
77039
77040   {
77041     try {
77042       result = (Dali::Toolkit::TextEditor::Property *)new Dali::Toolkit::TextEditor::Property();
77043     } catch (std::out_of_range& e) {
77044       {
77045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77046       };
77047     } catch (std::exception& e) {
77048       {
77049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77050       };
77051     } catch (...) {
77052       {
77053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77054       };
77055     }
77056   }
77057   jresult = (void *)result;
77058   return jresult;
77059 }
77060
77061
77062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_Property(void * jarg1) {
77063   Dali::Toolkit::TextEditor::Property *arg1 = (Dali::Toolkit::TextEditor::Property *) 0 ;
77064
77065   arg1 = (Dali::Toolkit::TextEditor::Property *)jarg1;
77066   {
77067     try {
77068       delete arg1;
77069     } catch (std::out_of_range& e) {
77070       {
77071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77072       };
77073     } catch (std::exception& e) {
77074       {
77075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77076       };
77077     } catch (...) {
77078       {
77079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77080       };
77081     }
77082   }
77083 }
77084
77085
77086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_InputStyle() {
77087   void * jresult ;
77088   Dali::Toolkit::TextEditor::InputStyle *result = 0 ;
77089
77090   {
77091     try {
77092       result = (Dali::Toolkit::TextEditor::InputStyle *)new Dali::Toolkit::TextEditor::InputStyle();
77093     } catch (std::out_of_range& e) {
77094       {
77095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77096       };
77097     } catch (std::exception& e) {
77098       {
77099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77100       };
77101     } catch (...) {
77102       {
77103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77104       };
77105     }
77106   }
77107   jresult = (void *)result;
77108   return jresult;
77109 }
77110
77111
77112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_InputStyle(void * jarg1) {
77113   Dali::Toolkit::TextEditor::InputStyle *arg1 = (Dali::Toolkit::TextEditor::InputStyle *) 0 ;
77114
77115   arg1 = (Dali::Toolkit::TextEditor::InputStyle *)jarg1;
77116   {
77117     try {
77118       delete arg1;
77119     } catch (std::out_of_range& e) {
77120       {
77121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77122       };
77123     } catch (std::exception& e) {
77124       {
77125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77126       };
77127     } catch (...) {
77128       {
77129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77130       };
77131     }
77132   }
77133 }
77134
77135
77136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_New() {
77137   void * jresult ;
77138   Dali::Toolkit::TextEditor result;
77139
77140   {
77141     try {
77142       result = Dali::Toolkit::TextEditor::New();
77143     } catch (std::out_of_range& e) {
77144       {
77145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77146       };
77147     } catch (std::exception& e) {
77148       {
77149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77150       };
77151     } catch (...) {
77152       {
77153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77154       };
77155     }
77156   }
77157   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
77158   return jresult;
77159 }
77160
77161
77162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_0() {
77163   void * jresult ;
77164   Dali::Toolkit::TextEditor *result = 0 ;
77165
77166   {
77167     try {
77168       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor();
77169     } catch (std::out_of_range& e) {
77170       {
77171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77172       };
77173     } catch (std::exception& e) {
77174       {
77175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77176       };
77177     } catch (...) {
77178       {
77179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77180       };
77181     }
77182   }
77183   jresult = (void *)result;
77184   return jresult;
77185 }
77186
77187
77188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_1(void * jarg1) {
77189   void * jresult ;
77190   Dali::Toolkit::TextEditor *arg1 = 0 ;
77191   Dali::Toolkit::TextEditor *result = 0 ;
77192
77193   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77194   if (!arg1) {
77195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
77196     return 0;
77197   }
77198   {
77199     try {
77200       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor((Dali::Toolkit::TextEditor const &)*arg1);
77201     } catch (std::out_of_range& e) {
77202       {
77203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77204       };
77205     } catch (std::exception& e) {
77206       {
77207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77208       };
77209     } catch (...) {
77210       {
77211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77212       };
77213     }
77214   }
77215   jresult = (void *)result;
77216   return jresult;
77217 }
77218
77219
77220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_Assign(void * jarg1, void * jarg2) {
77221   void * jresult ;
77222   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77223   Dali::Toolkit::TextEditor *arg2 = 0 ;
77224   Dali::Toolkit::TextEditor *result = 0 ;
77225
77226   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77227   arg2 = (Dali::Toolkit::TextEditor *)jarg2;
77228   if (!arg2) {
77229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
77230     return 0;
77231   }
77232   {
77233     try {
77234       result = (Dali::Toolkit::TextEditor *) &(arg1)->operator =((Dali::Toolkit::TextEditor const &)*arg2);
77235     } catch (std::out_of_range& e) {
77236       {
77237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77238       };
77239     } catch (std::exception& e) {
77240       {
77241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77242       };
77243     } catch (...) {
77244       {
77245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77246       };
77247     }
77248   }
77249   jresult = (void *)result;
77250   return jresult;
77251 }
77252
77253
77254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor(void * jarg1) {
77255   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77256
77257   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77258   {
77259     try {
77260       delete arg1;
77261     } catch (std::out_of_range& e) {
77262       {
77263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77264       };
77265     } catch (std::exception& e) {
77266       {
77267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77268       };
77269     } catch (...) {
77270       {
77271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77272       };
77273     }
77274   }
77275 }
77276
77277
77278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_DownCast(void * jarg1) {
77279   void * jresult ;
77280   Dali::BaseHandle arg1 ;
77281   Dali::BaseHandle *argp1 ;
77282   Dali::Toolkit::TextEditor result;
77283
77284   argp1 = (Dali::BaseHandle *)jarg1;
77285   if (!argp1) {
77286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77287     return 0;
77288   }
77289   arg1 = *argp1;
77290   {
77291     try {
77292       result = Dali::Toolkit::TextEditor::DownCast(arg1);
77293     } catch (std::out_of_range& e) {
77294       {
77295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77296       };
77297     } catch (std::exception& e) {
77298       {
77299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77300       };
77301     } catch (...) {
77302       {
77303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77304       };
77305     }
77306   }
77307   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
77308   return jresult;
77309 }
77310
77311
77312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_TextChangedSignal(void * jarg1) {
77313   void * jresult ;
77314   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77315   Dali::Toolkit::TextEditor::TextChangedSignalType *result = 0 ;
77316
77317   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77318   {
77319     try {
77320       result = (Dali::Toolkit::TextEditor::TextChangedSignalType *) &(arg1)->TextChangedSignal();
77321     } catch (std::out_of_range& e) {
77322       {
77323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77324       };
77325     } catch (std::exception& e) {
77326       {
77327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77328       };
77329     } catch (...) {
77330       {
77331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77332       };
77333     }
77334   }
77335   jresult = (void *)result;
77336   return jresult;
77337 }
77338
77339
77340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_InputStyleChangedSignal(void * jarg1) {
77341   void * jresult ;
77342   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77343   Dali::Toolkit::TextEditor::InputStyleChangedSignalType *result = 0 ;
77344
77345   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77346   {
77347     try {
77348       result = (Dali::Toolkit::TextEditor::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
77349     } catch (std::out_of_range& e) {
77350       {
77351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77352       };
77353     } catch (std::exception& e) {
77354       {
77355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77356       };
77357     } catch (...) {
77358       {
77359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77360       };
77361     }
77362   }
77363   jresult = (void *)result;
77364   return jresult;
77365 }
77366
77367
77368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_RENDERING_BACKEND_get() {
77369   int jresult ;
77370   int result;
77371
77372   result = (int)Dali::Toolkit::TextField::Property::RENDERING_BACKEND;
77373   jresult = (int)result;
77374   return jresult;
77375 }
77376
77377
77378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_get() {
77379   int jresult ;
77380   int result;
77381
77382   result = (int)Dali::Toolkit::TextField::Property::TEXT;
77383   jresult = (int)result;
77384   return jresult;
77385 }
77386
77387
77388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_get() {
77389   int jresult ;
77390   int result;
77391
77392   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT;
77393   jresult = (int)result;
77394   return jresult;
77395 }
77396
77397
77398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_FOCUSED_get() {
77399   int jresult ;
77400   int result;
77401
77402   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_FOCUSED;
77403   jresult = (int)result;
77404   return jresult;
77405 }
77406
77407
77408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_FAMILY_get() {
77409   int jresult ;
77410   int result;
77411
77412   result = (int)Dali::Toolkit::TextField::Property::FONT_FAMILY;
77413   jresult = (int)result;
77414   return jresult;
77415 }
77416
77417
77418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_STYLE_get() {
77419   int jresult ;
77420   int result;
77421
77422   result = (int)Dali::Toolkit::TextField::Property::FONT_STYLE;
77423   jresult = (int)result;
77424   return jresult;
77425 }
77426
77427
77428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_POINT_SIZE_get() {
77429   int jresult ;
77430   int result;
77431
77432   result = (int)Dali::Toolkit::TextField::Property::POINT_SIZE;
77433   jresult = (int)result;
77434   return jresult;
77435 }
77436
77437
77438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_MAX_LENGTH_get() {
77439   int jresult ;
77440   int result;
77441
77442   result = (int)Dali::Toolkit::TextField::Property::MAX_LENGTH;
77443   jresult = (int)result;
77444   return jresult;
77445 }
77446
77447
77448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EXCEED_POLICY_get() {
77449   int jresult ;
77450   int result;
77451
77452   result = (int)Dali::Toolkit::TextField::Property::EXCEED_POLICY;
77453   jresult = (int)result;
77454   return jresult;
77455 }
77456
77457
77458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_HORIZONTAL_ALIGNMENT_get() {
77459   int jresult ;
77460   int result;
77461
77462   result = (int)Dali::Toolkit::TextField::Property::HORIZONTAL_ALIGNMENT;
77463   jresult = (int)result;
77464   return jresult;
77465 }
77466
77467
77468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_VERTICAL_ALIGNMENT_get() {
77469   int jresult ;
77470   int result;
77471
77472   result = (int)Dali::Toolkit::TextField::Property::VERTICAL_ALIGNMENT;
77473   jresult = (int)result;
77474   return jresult;
77475 }
77476
77477
77478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_COLOR_get() {
77479   int jresult ;
77480   int result;
77481
77482   result = (int)Dali::Toolkit::TextField::Property::TEXT_COLOR;
77483   jresult = (int)result;
77484   return jresult;
77485 }
77486
77487
77488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_COLOR_get() {
77489   int jresult ;
77490   int result;
77491
77492   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_COLOR;
77493   jresult = (int)result;
77494   return jresult;
77495 }
77496
77497
77498 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_OFFSET_get() {
77499   int jresult ;
77500   int result;
77501
77502   result = (int)Dali::Toolkit::TextField::Property::SHADOW_OFFSET;
77503   jresult = (int)result;
77504   return jresult;
77505 }
77506
77507
77508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_COLOR_get() {
77509   int jresult ;
77510   int result;
77511
77512   result = (int)Dali::Toolkit::TextField::Property::SHADOW_COLOR;
77513   jresult = (int)result;
77514   return jresult;
77515 }
77516
77517
77518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PRIMARY_CURSOR_COLOR_get() {
77519   int jresult ;
77520   int result;
77521
77522   result = (int)Dali::Toolkit::TextField::Property::PRIMARY_CURSOR_COLOR;
77523   jresult = (int)result;
77524   return jresult;
77525 }
77526
77527
77528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SECONDARY_CURSOR_COLOR_get() {
77529   int jresult ;
77530   int result;
77531
77532   result = (int)Dali::Toolkit::TextField::Property::SECONDARY_CURSOR_COLOR;
77533   jresult = (int)result;
77534   return jresult;
77535 }
77536
77537
77538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_CURSOR_BLINK_get() {
77539   int jresult ;
77540   int result;
77541
77542   result = (int)Dali::Toolkit::TextField::Property::ENABLE_CURSOR_BLINK;
77543   jresult = (int)result;
77544   return jresult;
77545 }
77546
77547
77548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_INTERVAL_get() {
77549   int jresult ;
77550   int result;
77551
77552   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_INTERVAL;
77553   jresult = (int)result;
77554   return jresult;
77555 }
77556
77557
77558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_DURATION_get() {
77559   int jresult ;
77560   int result;
77561
77562   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_DURATION;
77563   jresult = (int)result;
77564   return jresult;
77565 }
77566
77567
77568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_WIDTH_get() {
77569   int jresult ;
77570   int result;
77571
77572   result = (int)Dali::Toolkit::TextField::Property::CURSOR_WIDTH;
77573   jresult = (int)result;
77574   return jresult;
77575 }
77576
77577
77578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_IMAGE_get() {
77579   int jresult ;
77580   int result;
77581
77582   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_IMAGE;
77583   jresult = (int)result;
77584   return jresult;
77585 }
77586
77587
77588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
77589   int jresult ;
77590   int result;
77591
77592   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_PRESSED_IMAGE;
77593   jresult = (int)result;
77594   return jresult;
77595 }
77596
77597
77598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_THRESHOLD_get() {
77599   int jresult ;
77600   int result;
77601
77602   result = (int)Dali::Toolkit::TextField::Property::SCROLL_THRESHOLD;
77603   jresult = (int)result;
77604   return jresult;
77605 }
77606
77607
77608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_SPEED_get() {
77609   int jresult ;
77610   int result;
77611
77612   result = (int)Dali::Toolkit::TextField::Property::SCROLL_SPEED;
77613   jresult = (int)result;
77614   return jresult;
77615 }
77616
77617
77618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
77619   int jresult ;
77620   int result;
77621
77622   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_LEFT;
77623   jresult = (int)result;
77624   return jresult;
77625 }
77626
77627
77628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
77629   int jresult ;
77630   int result;
77631
77632   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT;
77633   jresult = (int)result;
77634   return jresult;
77635 }
77636
77637
77638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
77639   int jresult ;
77640   int result;
77641
77642   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
77643   jresult = (int)result;
77644   return jresult;
77645 }
77646
77647
77648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
77649   int jresult ;
77650   int result;
77651
77652   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
77653   jresult = (int)result;
77654   return jresult;
77655 }
77656
77657
77658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
77659   int jresult ;
77660   int result;
77661
77662   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
77663   jresult = (int)result;
77664   return jresult;
77665 }
77666
77667
77668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
77669   int jresult ;
77670   int result;
77671
77672   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
77673   jresult = (int)result;
77674   return jresult;
77675 }
77676
77677
77678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HIGHLIGHT_COLOR_get() {
77679   int jresult ;
77680   int result;
77681
77682   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HIGHLIGHT_COLOR;
77683   jresult = (int)result;
77684   return jresult;
77685 }
77686
77687
77688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_DECORATION_BOUNDING_BOX_get() {
77689   int jresult ;
77690   int result;
77691
77692   result = (int)Dali::Toolkit::TextField::Property::DECORATION_BOUNDING_BOX;
77693   jresult = (int)result;
77694   return jresult;
77695 }
77696
77697
77698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_METHOD_SETTINGS_get() {
77699   int jresult ;
77700   int result;
77701
77702   result = (int)Dali::Toolkit::TextField::Property::INPUT_METHOD_SETTINGS;
77703   jresult = (int)result;
77704   return jresult;
77705 }
77706
77707
77708 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_COLOR_get() {
77709   int jresult ;
77710   int result;
77711
77712   result = (int)Dali::Toolkit::TextField::Property::INPUT_COLOR;
77713   jresult = (int)result;
77714   return jresult;
77715 }
77716
77717
77718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_MARKUP_get() {
77719   int jresult ;
77720   int result;
77721
77722   result = (int)Dali::Toolkit::TextField::Property::ENABLE_MARKUP;
77723   jresult = (int)result;
77724   return jresult;
77725 }
77726
77727
77728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_FAMILY_get() {
77729   int jresult ;
77730   int result;
77731
77732   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_FAMILY;
77733   jresult = (int)result;
77734   return jresult;
77735 }
77736
77737
77738 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_STYLE_get() {
77739   int jresult ;
77740   int result;
77741
77742   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_STYLE;
77743   jresult = (int)result;
77744   return jresult;
77745 }
77746
77747
77748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_POINT_SIZE_get() {
77749   int jresult ;
77750   int result;
77751
77752   result = (int)Dali::Toolkit::TextField::Property::INPUT_POINT_SIZE;
77753   jresult = (int)result;
77754   return jresult;
77755 }
77756
77757
77758 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_UNDERLINE_get() {
77759   int jresult ;
77760   int result;
77761
77762   result = (int)Dali::Toolkit::TextField::Property::UNDERLINE;
77763   jresult = (int)result;
77764   return jresult;
77765 }
77766
77767
77768 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_UNDERLINE_get() {
77769   int jresult ;
77770   int result;
77771
77772   result = (int)Dali::Toolkit::TextField::Property::INPUT_UNDERLINE;
77773   jresult = (int)result;
77774   return jresult;
77775 }
77776
77777
77778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_get() {
77779   int jresult ;
77780   int result;
77781
77782   result = (int)Dali::Toolkit::TextField::Property::SHADOW;
77783   jresult = (int)result;
77784   return jresult;
77785 }
77786
77787
77788 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_SHADOW_get() {
77789   int jresult ;
77790   int result;
77791
77792   result = (int)Dali::Toolkit::TextField::Property::INPUT_SHADOW;
77793   jresult = (int)result;
77794   return jresult;
77795 }
77796
77797
77798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EMBOSS_get() {
77799   int jresult ;
77800   int result;
77801
77802   result = (int)Dali::Toolkit::TextField::Property::EMBOSS;
77803   jresult = (int)result;
77804   return jresult;
77805 }
77806
77807
77808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_EMBOSS_get() {
77809   int jresult ;
77810   int result;
77811
77812   result = (int)Dali::Toolkit::TextField::Property::INPUT_EMBOSS;
77813   jresult = (int)result;
77814   return jresult;
77815 }
77816
77817
77818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_OUTLINE_get() {
77819   int jresult ;
77820   int result;
77821
77822   result = (int)Dali::Toolkit::TextField::Property::OUTLINE;
77823   jresult = (int)result;
77824   return jresult;
77825 }
77826
77827
77828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_OUTLINE_get() {
77829   int jresult ;
77830   int result;
77831
77832   result = (int)Dali::Toolkit::TextField::Property::INPUT_OUTLINE;
77833   jresult = (int)result;
77834   return jresult;
77835 }
77836
77837
77838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_Property() {
77839   void * jresult ;
77840   Dali::Toolkit::TextField::Property *result = 0 ;
77841
77842   {
77843     try {
77844       result = (Dali::Toolkit::TextField::Property *)new Dali::Toolkit::TextField::Property();
77845     } catch (std::out_of_range& e) {
77846       {
77847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77848       };
77849     } catch (std::exception& e) {
77850       {
77851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77852       };
77853     } catch (...) {
77854       {
77855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77856       };
77857     }
77858   }
77859   jresult = (void *)result;
77860   return jresult;
77861 }
77862
77863
77864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_Property(void * jarg1) {
77865   Dali::Toolkit::TextField::Property *arg1 = (Dali::Toolkit::TextField::Property *) 0 ;
77866
77867   arg1 = (Dali::Toolkit::TextField::Property *)jarg1;
77868   {
77869     try {
77870       delete arg1;
77871     } catch (std::out_of_range& e) {
77872       {
77873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77874       };
77875     } catch (std::exception& e) {
77876       {
77877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77878       };
77879     } catch (...) {
77880       {
77881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77882       };
77883     }
77884   }
77885 }
77886
77887
77888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_InputStyle() {
77889   void * jresult ;
77890   Dali::Toolkit::TextField::InputStyle *result = 0 ;
77891
77892   {
77893     try {
77894       result = (Dali::Toolkit::TextField::InputStyle *)new Dali::Toolkit::TextField::InputStyle();
77895     } catch (std::out_of_range& e) {
77896       {
77897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77898       };
77899     } catch (std::exception& e) {
77900       {
77901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77902       };
77903     } catch (...) {
77904       {
77905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77906       };
77907     }
77908   }
77909   jresult = (void *)result;
77910   return jresult;
77911 }
77912
77913
77914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_InputStyle(void * jarg1) {
77915   Dali::Toolkit::TextField::InputStyle *arg1 = (Dali::Toolkit::TextField::InputStyle *) 0 ;
77916
77917   arg1 = (Dali::Toolkit::TextField::InputStyle *)jarg1;
77918   {
77919     try {
77920       delete arg1;
77921     } catch (std::out_of_range& e) {
77922       {
77923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77924       };
77925     } catch (std::exception& e) {
77926       {
77927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77928       };
77929     } catch (...) {
77930       {
77931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77932       };
77933     }
77934   }
77935 }
77936
77937
77938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_New() {
77939   void * jresult ;
77940   Dali::Toolkit::TextField result;
77941
77942   {
77943     try {
77944       result = Dali::Toolkit::TextField::New();
77945     } catch (std::out_of_range& e) {
77946       {
77947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77948       };
77949     } catch (std::exception& e) {
77950       {
77951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77952       };
77953     } catch (...) {
77954       {
77955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77956       };
77957     }
77958   }
77959   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
77960   return jresult;
77961 }
77962
77963
77964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_0() {
77965   void * jresult ;
77966   Dali::Toolkit::TextField *result = 0 ;
77967
77968   {
77969     try {
77970       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField();
77971     } catch (std::out_of_range& e) {
77972       {
77973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77974       };
77975     } catch (std::exception& e) {
77976       {
77977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77978       };
77979     } catch (...) {
77980       {
77981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77982       };
77983     }
77984   }
77985   jresult = (void *)result;
77986   return jresult;
77987 }
77988
77989
77990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_1(void * jarg1) {
77991   void * jresult ;
77992   Dali::Toolkit::TextField *arg1 = 0 ;
77993   Dali::Toolkit::TextField *result = 0 ;
77994
77995   arg1 = (Dali::Toolkit::TextField *)jarg1;
77996   if (!arg1) {
77997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
77998     return 0;
77999   }
78000   {
78001     try {
78002       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField((Dali::Toolkit::TextField const &)*arg1);
78003     } catch (std::out_of_range& e) {
78004       {
78005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78006       };
78007     } catch (std::exception& e) {
78008       {
78009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78010       };
78011     } catch (...) {
78012       {
78013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78014       };
78015     }
78016   }
78017   jresult = (void *)result;
78018   return jresult;
78019 }
78020
78021
78022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_Assign(void * jarg1, void * jarg2) {
78023   void * jresult ;
78024   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78025   Dali::Toolkit::TextField *arg2 = 0 ;
78026   Dali::Toolkit::TextField *result = 0 ;
78027
78028   arg1 = (Dali::Toolkit::TextField *)jarg1;
78029   arg2 = (Dali::Toolkit::TextField *)jarg2;
78030   if (!arg2) {
78031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
78032     return 0;
78033   }
78034   {
78035     try {
78036       result = (Dali::Toolkit::TextField *) &(arg1)->operator =((Dali::Toolkit::TextField const &)*arg2);
78037     } catch (std::out_of_range& e) {
78038       {
78039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78040       };
78041     } catch (std::exception& e) {
78042       {
78043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78044       };
78045     } catch (...) {
78046       {
78047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78048       };
78049     }
78050   }
78051   jresult = (void *)result;
78052   return jresult;
78053 }
78054
78055
78056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField(void * jarg1) {
78057   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78058
78059   arg1 = (Dali::Toolkit::TextField *)jarg1;
78060   {
78061     try {
78062       delete arg1;
78063     } catch (std::out_of_range& e) {
78064       {
78065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78066       };
78067     } catch (std::exception& e) {
78068       {
78069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78070       };
78071     } catch (...) {
78072       {
78073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78074       };
78075     }
78076   }
78077 }
78078
78079
78080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_DownCast(void * jarg1) {
78081   void * jresult ;
78082   Dali::BaseHandle arg1 ;
78083   Dali::BaseHandle *argp1 ;
78084   Dali::Toolkit::TextField result;
78085
78086   argp1 = (Dali::BaseHandle *)jarg1;
78087   if (!argp1) {
78088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78089     return 0;
78090   }
78091   arg1 = *argp1;
78092   {
78093     try {
78094       result = Dali::Toolkit::TextField::DownCast(arg1);
78095     } catch (std::out_of_range& e) {
78096       {
78097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78098       };
78099     } catch (std::exception& e) {
78100       {
78101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78102       };
78103     } catch (...) {
78104       {
78105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78106       };
78107     }
78108   }
78109   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
78110   return jresult;
78111 }
78112
78113
78114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_TextChangedSignal(void * jarg1) {
78115   void * jresult ;
78116   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78117   Dali::Toolkit::TextField::TextChangedSignalType *result = 0 ;
78118
78119   arg1 = (Dali::Toolkit::TextField *)jarg1;
78120   {
78121     try {
78122       result = (Dali::Toolkit::TextField::TextChangedSignalType *) &(arg1)->TextChangedSignal();
78123     } catch (std::out_of_range& e) {
78124       {
78125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78126       };
78127     } catch (std::exception& e) {
78128       {
78129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78130       };
78131     } catch (...) {
78132       {
78133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78134       };
78135     }
78136   }
78137   jresult = (void *)result;
78138   return jresult;
78139 }
78140
78141
78142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_MaxLengthReachedSignal(void * jarg1) {
78143   void * jresult ;
78144   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78145   Dali::Toolkit::TextField::MaxLengthReachedSignalType *result = 0 ;
78146
78147   arg1 = (Dali::Toolkit::TextField *)jarg1;
78148   {
78149     try {
78150       result = (Dali::Toolkit::TextField::MaxLengthReachedSignalType *) &(arg1)->MaxLengthReachedSignal();
78151     } catch (std::out_of_range& e) {
78152       {
78153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78154       };
78155     } catch (std::exception& e) {
78156       {
78157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78158       };
78159     } catch (...) {
78160       {
78161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78162       };
78163     }
78164   }
78165   jresult = (void *)result;
78166   return jresult;
78167 }
78168
78169
78170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_InputStyleChangedSignal(void * jarg1) {
78171   void * jresult ;
78172   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78173   Dali::Toolkit::TextField::InputStyleChangedSignalType *result = 0 ;
78174
78175   arg1 = (Dali::Toolkit::TextField *)jarg1;
78176   {
78177     try {
78178       result = (Dali::Toolkit::TextField::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
78179     } catch (std::out_of_range& e) {
78180       {
78181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78182       };
78183     } catch (std::exception& e) {
78184       {
78185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78186       };
78187     } catch (...) {
78188       {
78189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78190       };
78191     }
78192   }
78193   jresult = (void *)result;
78194   return jresult;
78195 }
78196
78197
78198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
78199   int jresult ;
78200   int result;
78201
78202   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
78203   jresult = (int)result;
78204   return jresult;
78205 }
78206
78207
78208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
78209   int jresult ;
78210   int result;
78211
78212   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
78213   jresult = (int)result;
78214   return jresult;
78215 }
78216
78217
78218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
78219   int jresult ;
78220   int result;
78221
78222   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
78223   jresult = (int)result;
78224   return jresult;
78225 }
78226
78227
78228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
78229   int jresult ;
78230   int result;
78231
78232   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
78233   jresult = (int)result;
78234   return jresult;
78235 }
78236
78237
78238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
78239   int jresult ;
78240   int result;
78241
78242   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
78243   jresult = (int)result;
78244   return jresult;
78245 }
78246
78247
78248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
78249   int jresult ;
78250   int result;
78251
78252   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
78253   jresult = (int)result;
78254   return jresult;
78255 }
78256
78257
78258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
78259   int jresult ;
78260   int result;
78261
78262   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
78263   jresult = (int)result;
78264   return jresult;
78265 }
78266
78267
78268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
78269   int jresult ;
78270   int result;
78271
78272   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
78273   jresult = (int)result;
78274   return jresult;
78275 }
78276
78277
78278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
78279   int jresult ;
78280   int result;
78281
78282   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
78283   jresult = (int)result;
78284   return jresult;
78285 }
78286
78287
78288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
78289   int jresult ;
78290   int result;
78291
78292   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
78293   jresult = (int)result;
78294   return jresult;
78295 }
78296
78297
78298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
78299   int jresult ;
78300   int result;
78301
78302   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
78303   jresult = (int)result;
78304   return jresult;
78305 }
78306
78307
78308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
78309   int jresult ;
78310   int result;
78311
78312   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
78313   jresult = (int)result;
78314   return jresult;
78315 }
78316
78317
78318 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
78319   int jresult ;
78320   int result;
78321
78322   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
78323   jresult = (int)result;
78324   return jresult;
78325 }
78326
78327
78328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
78329   int jresult ;
78330   int result;
78331
78332   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
78333   jresult = (int)result;
78334   return jresult;
78335 }
78336
78337
78338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
78339   int jresult ;
78340   int result;
78341
78342   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
78343   jresult = (int)result;
78344   return jresult;
78345 }
78346
78347
78348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
78349   int jresult ;
78350   int result;
78351
78352   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
78353   jresult = (int)result;
78354   return jresult;
78355 }
78356
78357
78358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
78359   int jresult ;
78360   int result;
78361
78362   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
78363   jresult = (int)result;
78364   return jresult;
78365 }
78366
78367
78368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
78369   int jresult ;
78370   int result;
78371
78372   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
78373   jresult = (int)result;
78374   return jresult;
78375 }
78376
78377
78378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
78379   int jresult ;
78380   int result;
78381
78382   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
78383   jresult = (int)result;
78384   return jresult;
78385 }
78386
78387
78388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
78389   int jresult ;
78390   int result;
78391
78392   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
78393   jresult = (int)result;
78394   return jresult;
78395 }
78396
78397
78398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
78399   int jresult ;
78400   int result;
78401
78402   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
78403   jresult = (int)result;
78404   return jresult;
78405 }
78406
78407
78408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
78409   int jresult ;
78410   int result;
78411
78412   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
78413   jresult = (int)result;
78414   return jresult;
78415 }
78416
78417
78418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
78419   int jresult ;
78420   int result;
78421
78422   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
78423   jresult = (int)result;
78424   return jresult;
78425 }
78426
78427
78428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
78429   int jresult ;
78430   int result;
78431
78432   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
78433   jresult = (int)result;
78434   return jresult;
78435 }
78436
78437
78438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
78439   void * jresult ;
78440   Dali::Toolkit::TextLabel::Property *result = 0 ;
78441
78442   {
78443     try {
78444       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
78445     } catch (std::out_of_range& e) {
78446       {
78447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78448       };
78449     } catch (std::exception& e) {
78450       {
78451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78452       };
78453     } catch (...) {
78454       {
78455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78456       };
78457     }
78458   }
78459   jresult = (void *)result;
78460   return jresult;
78461 }
78462
78463
78464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
78465   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
78466
78467   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
78468   {
78469     try {
78470       delete arg1;
78471     } catch (std::out_of_range& e) {
78472       {
78473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78474       };
78475     } catch (std::exception& e) {
78476       {
78477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78478       };
78479     } catch (...) {
78480       {
78481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78482       };
78483     }
78484   }
78485 }
78486
78487
78488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
78489   void * jresult ;
78490   Dali::Toolkit::TextLabel result;
78491
78492   {
78493     try {
78494       result = Dali::Toolkit::TextLabel::New();
78495     } catch (std::out_of_range& e) {
78496       {
78497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78498       };
78499     } catch (std::exception& e) {
78500       {
78501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78502       };
78503     } catch (...) {
78504       {
78505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78506       };
78507     }
78508   }
78509   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78510   return jresult;
78511 }
78512
78513
78514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
78515   void * jresult ;
78516   std::string *arg1 = 0 ;
78517   Dali::Toolkit::TextLabel result;
78518
78519   if (!jarg1) {
78520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78521     return 0;
78522   }
78523   std::string arg1_str(jarg1);
78524   arg1 = &arg1_str;
78525   {
78526     try {
78527       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
78528     } catch (std::out_of_range& e) {
78529       {
78530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78531       };
78532     } catch (std::exception& e) {
78533       {
78534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78535       };
78536     } catch (...) {
78537       {
78538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78539       };
78540     }
78541   }
78542   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78543
78544   //argout typemap for const std::string&
78545
78546   return jresult;
78547 }
78548
78549
78550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
78551   void * jresult ;
78552   Dali::Toolkit::TextLabel *result = 0 ;
78553
78554   {
78555     try {
78556       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
78557     } catch (std::out_of_range& e) {
78558       {
78559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78560       };
78561     } catch (std::exception& e) {
78562       {
78563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78564       };
78565     } catch (...) {
78566       {
78567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78568       };
78569     }
78570   }
78571   jresult = (void *)result;
78572   return jresult;
78573 }
78574
78575
78576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
78577   void * jresult ;
78578   Dali::Toolkit::TextLabel *arg1 = 0 ;
78579   Dali::Toolkit::TextLabel *result = 0 ;
78580
78581   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78582   if (!arg1) {
78583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78584     return 0;
78585   }
78586   {
78587     try {
78588       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
78589     } catch (std::out_of_range& e) {
78590       {
78591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78592       };
78593     } catch (std::exception& e) {
78594       {
78595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78596       };
78597     } catch (...) {
78598       {
78599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78600       };
78601     }
78602   }
78603   jresult = (void *)result;
78604   return jresult;
78605 }
78606
78607
78608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
78609   void * jresult ;
78610   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78611   Dali::Toolkit::TextLabel *arg2 = 0 ;
78612   Dali::Toolkit::TextLabel *result = 0 ;
78613
78614   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78615   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
78616   if (!arg2) {
78617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78618     return 0;
78619   }
78620   {
78621     try {
78622       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
78623     } catch (std::out_of_range& e) {
78624       {
78625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78626       };
78627     } catch (std::exception& e) {
78628       {
78629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78630       };
78631     } catch (...) {
78632       {
78633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78634       };
78635     }
78636   }
78637   jresult = (void *)result;
78638   return jresult;
78639 }
78640
78641
78642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
78643   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78644
78645   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78646   {
78647     try {
78648       delete arg1;
78649     } catch (std::out_of_range& e) {
78650       {
78651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78652       };
78653     } catch (std::exception& e) {
78654       {
78655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78656       };
78657     } catch (...) {
78658       {
78659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78660       };
78661     }
78662   }
78663 }
78664
78665
78666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
78667   void * jresult ;
78668   Dali::BaseHandle arg1 ;
78669   Dali::BaseHandle *argp1 ;
78670   Dali::Toolkit::TextLabel result;
78671
78672   argp1 = (Dali::BaseHandle *)jarg1;
78673   if (!argp1) {
78674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78675     return 0;
78676   }
78677   arg1 = *argp1;
78678   {
78679     try {
78680       result = Dali::Toolkit::TextLabel::DownCast(arg1);
78681     } catch (std::out_of_range& e) {
78682       {
78683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78684       };
78685     } catch (std::exception& e) {
78686       {
78687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78688       };
78689     } catch (...) {
78690       {
78691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78692       };
78693     }
78694   }
78695   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78696   return jresult;
78697 }
78698
78699
78700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
78701   void * jresult ;
78702   Dali::Toolkit::AccessibilityManager *result = 0 ;
78703
78704   {
78705     try {
78706       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
78707     } catch (std::out_of_range& e) {
78708       {
78709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78710       };
78711     } catch (std::exception& e) {
78712       {
78713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78714       };
78715     } catch (...) {
78716       {
78717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78718       };
78719     }
78720   }
78721   jresult = (void *)result;
78722   return jresult;
78723 }
78724
78725
78726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
78727   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78728
78729   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78730   {
78731     try {
78732       delete arg1;
78733     } catch (std::out_of_range& e) {
78734       {
78735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78736       };
78737     } catch (std::exception& e) {
78738       {
78739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78740       };
78741     } catch (...) {
78742       {
78743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78744       };
78745     }
78746   }
78747 }
78748
78749
78750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
78751   void * jresult ;
78752   Dali::Toolkit::AccessibilityManager result;
78753
78754   {
78755     try {
78756       result = Dali::Toolkit::AccessibilityManager::Get();
78757     } catch (std::out_of_range& e) {
78758       {
78759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78760       };
78761     } catch (std::exception& e) {
78762       {
78763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78764       };
78765     } catch (...) {
78766       {
78767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78768       };
78769     }
78770   }
78771   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
78772   return jresult;
78773 }
78774
78775
78776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
78777   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78778   Dali::Actor arg2 ;
78779   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
78780   std::string *arg4 = 0 ;
78781   Dali::Actor *argp2 ;
78782
78783   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78784   argp2 = (Dali::Actor *)jarg2;
78785   if (!argp2) {
78786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78787     return ;
78788   }
78789   arg2 = *argp2;
78790   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
78791   if (!jarg4) {
78792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78793     return ;
78794   }
78795   std::string arg4_str(jarg4);
78796   arg4 = &arg4_str;
78797   {
78798     try {
78799       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
78800     } catch (std::out_of_range& e) {
78801       {
78802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78803       };
78804     } catch (std::exception& e) {
78805       {
78806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78807       };
78808     } catch (...) {
78809       {
78810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78811       };
78812     }
78813   }
78814
78815   //argout typemap for const std::string&
78816
78817 }
78818
78819
78820 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
78821   char * jresult ;
78822   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78823   Dali::Actor arg2 ;
78824   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
78825   Dali::Actor *argp2 ;
78826   std::string result;
78827
78828   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78829   argp2 = (Dali::Actor *)jarg2;
78830   if (!argp2) {
78831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78832     return 0;
78833   }
78834   arg2 = *argp2;
78835   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
78836   {
78837     try {
78838       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
78839     } catch (std::out_of_range& e) {
78840       {
78841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78842       };
78843     } catch (std::exception& e) {
78844       {
78845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78846       };
78847     } catch (...) {
78848       {
78849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78850       };
78851     }
78852   }
78853   jresult = SWIG_csharp_string_callback((&result)->c_str());
78854   return jresult;
78855 }
78856
78857
78858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
78859   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78860   Dali::Actor arg2 ;
78861   unsigned int arg3 ;
78862   Dali::Actor *argp2 ;
78863
78864   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78865   argp2 = (Dali::Actor *)jarg2;
78866   if (!argp2) {
78867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78868     return ;
78869   }
78870   arg2 = *argp2;
78871   arg3 = (unsigned int)jarg3;
78872   {
78873     try {
78874       (arg1)->SetFocusOrder(arg2,arg3);
78875     } catch (std::out_of_range& e) {
78876       {
78877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78878       };
78879     } catch (std::exception& e) {
78880       {
78881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78882       };
78883     } catch (...) {
78884       {
78885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78886       };
78887     }
78888   }
78889 }
78890
78891
78892 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
78893   unsigned int jresult ;
78894   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78895   Dali::Actor arg2 ;
78896   Dali::Actor *argp2 ;
78897   unsigned int result;
78898
78899   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78900   argp2 = (Dali::Actor *)jarg2;
78901   if (!argp2) {
78902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78903     return 0;
78904   }
78905   arg2 = *argp2;
78906   {
78907     try {
78908       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
78909     } catch (std::out_of_range& e) {
78910       {
78911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78912       };
78913     } catch (std::exception& e) {
78914       {
78915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78916       };
78917     } catch (...) {
78918       {
78919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78920       };
78921     }
78922   }
78923   jresult = result;
78924   return jresult;
78925 }
78926
78927
78928 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
78929   unsigned int jresult ;
78930   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78931   unsigned int result;
78932
78933   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78934   {
78935     try {
78936       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
78937     } catch (std::out_of_range& e) {
78938       {
78939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78940       };
78941     } catch (std::exception& e) {
78942       {
78943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78944       };
78945     } catch (...) {
78946       {
78947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78948       };
78949     }
78950   }
78951   jresult = result;
78952   return jresult;
78953 }
78954
78955
78956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
78957   void * jresult ;
78958   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78959   unsigned int arg2 ;
78960   Dali::Actor result;
78961
78962   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78963   arg2 = (unsigned int)jarg2;
78964   {
78965     try {
78966       result = (arg1)->GetActorByFocusOrder(arg2);
78967     } catch (std::out_of_range& e) {
78968       {
78969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78970       };
78971     } catch (std::exception& e) {
78972       {
78973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78974       };
78975     } catch (...) {
78976       {
78977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78978       };
78979     }
78980   }
78981   jresult = new Dali::Actor((const Dali::Actor &)result);
78982   return jresult;
78983 }
78984
78985
78986 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
78987   unsigned int jresult ;
78988   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78989   Dali::Actor arg2 ;
78990   Dali::Actor *argp2 ;
78991   bool result;
78992
78993   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78994   argp2 = (Dali::Actor *)jarg2;
78995   if (!argp2) {
78996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78997     return 0;
78998   }
78999   arg2 = *argp2;
79000   {
79001     try {
79002       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
79003     } catch (std::out_of_range& e) {
79004       {
79005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79006       };
79007     } catch (std::exception& e) {
79008       {
79009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79010       };
79011     } catch (...) {
79012       {
79013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79014       };
79015     }
79016   }
79017   jresult = result;
79018   return jresult;
79019 }
79020
79021
79022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
79023   void * jresult ;
79024   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79025   Dali::Actor result;
79026
79027   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79028   {
79029     try {
79030       result = (arg1)->GetCurrentFocusActor();
79031     } catch (std::out_of_range& e) {
79032       {
79033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79034       };
79035     } catch (std::exception& e) {
79036       {
79037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79038       };
79039     } catch (...) {
79040       {
79041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79042       };
79043     }
79044   }
79045   jresult = new Dali::Actor((const Dali::Actor &)result);
79046   return jresult;
79047 }
79048
79049
79050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
79051   void * jresult ;
79052   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79053   Dali::Actor result;
79054
79055   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79056   {
79057     try {
79058       result = (arg1)->GetCurrentFocusGroup();
79059     } catch (std::out_of_range& e) {
79060       {
79061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79062       };
79063     } catch (std::exception& e) {
79064       {
79065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79066       };
79067     } catch (...) {
79068       {
79069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79070       };
79071     }
79072   }
79073   jresult = new Dali::Actor((const Dali::Actor &)result);
79074   return jresult;
79075 }
79076
79077
79078 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
79079   unsigned int jresult ;
79080   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79081   unsigned int result;
79082
79083   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79084   {
79085     try {
79086       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
79087     } catch (std::out_of_range& e) {
79088       {
79089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79090       };
79091     } catch (std::exception& e) {
79092       {
79093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79094       };
79095     } catch (...) {
79096       {
79097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79098       };
79099     }
79100   }
79101   jresult = result;
79102   return jresult;
79103 }
79104
79105
79106 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
79107   unsigned int jresult ;
79108   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79109   bool result;
79110
79111   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79112   {
79113     try {
79114       result = (bool)(arg1)->MoveFocusForward();
79115     } catch (std::out_of_range& e) {
79116       {
79117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79118       };
79119     } catch (std::exception& e) {
79120       {
79121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79122       };
79123     } catch (...) {
79124       {
79125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79126       };
79127     }
79128   }
79129   jresult = result;
79130   return jresult;
79131 }
79132
79133
79134 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
79135   unsigned int jresult ;
79136   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79137   bool result;
79138
79139   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79140   {
79141     try {
79142       result = (bool)(arg1)->MoveFocusBackward();
79143     } catch (std::out_of_range& e) {
79144       {
79145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79146       };
79147     } catch (std::exception& e) {
79148       {
79149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79150       };
79151     } catch (...) {
79152       {
79153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79154       };
79155     }
79156   }
79157   jresult = result;
79158   return jresult;
79159 }
79160
79161
79162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
79163   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79164
79165   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79166   {
79167     try {
79168       (arg1)->ClearFocus();
79169     } catch (std::out_of_range& e) {
79170       {
79171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79172       };
79173     } catch (std::exception& e) {
79174       {
79175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79176       };
79177     } catch (...) {
79178       {
79179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79180       };
79181     }
79182   }
79183 }
79184
79185
79186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
79187   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79188
79189   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79190   {
79191     try {
79192       (arg1)->Reset();
79193     } catch (std::out_of_range& e) {
79194       {
79195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79196       };
79197     } catch (std::exception& e) {
79198       {
79199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79200       };
79201     } catch (...) {
79202       {
79203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79204       };
79205     }
79206   }
79207 }
79208
79209
79210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
79211   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79212   Dali::Actor arg2 ;
79213   bool arg3 ;
79214   Dali::Actor *argp2 ;
79215
79216   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79217   argp2 = (Dali::Actor *)jarg2;
79218   if (!argp2) {
79219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79220     return ;
79221   }
79222   arg2 = *argp2;
79223   arg3 = jarg3 ? true : false;
79224   {
79225     try {
79226       (arg1)->SetFocusGroup(arg2,arg3);
79227     } catch (std::out_of_range& e) {
79228       {
79229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79230       };
79231     } catch (std::exception& e) {
79232       {
79233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79234       };
79235     } catch (...) {
79236       {
79237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79238       };
79239     }
79240   }
79241 }
79242
79243
79244 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
79245   unsigned int jresult ;
79246   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79247   Dali::Actor arg2 ;
79248   Dali::Actor *argp2 ;
79249   bool result;
79250
79251   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79252   argp2 = (Dali::Actor *)jarg2;
79253   if (!argp2) {
79254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79255     return 0;
79256   }
79257   arg2 = *argp2;
79258   {
79259     try {
79260       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
79261     } catch (std::out_of_range& e) {
79262       {
79263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79264       };
79265     } catch (std::exception& e) {
79266       {
79267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79268       };
79269     } catch (...) {
79270       {
79271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79272       };
79273     }
79274   }
79275   jresult = result;
79276   return jresult;
79277 }
79278
79279
79280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
79281   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79282   bool arg2 ;
79283
79284   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79285   arg2 = jarg2 ? true : false;
79286   {
79287     try {
79288       (arg1)->SetGroupMode(arg2);
79289     } catch (std::out_of_range& e) {
79290       {
79291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79292       };
79293     } catch (std::exception& e) {
79294       {
79295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79296       };
79297     } catch (...) {
79298       {
79299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79300       };
79301     }
79302   }
79303 }
79304
79305
79306 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
79307   unsigned int jresult ;
79308   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79309   bool result;
79310
79311   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79312   {
79313     try {
79314       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
79315     } catch (std::out_of_range& e) {
79316       {
79317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79318       };
79319     } catch (std::exception& e) {
79320       {
79321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79322       };
79323     } catch (...) {
79324       {
79325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79326       };
79327     }
79328   }
79329   jresult = result;
79330   return jresult;
79331 }
79332
79333
79334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
79335   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79336   bool arg2 ;
79337
79338   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79339   arg2 = jarg2 ? true : false;
79340   {
79341     try {
79342       (arg1)->SetWrapMode(arg2);
79343     } catch (std::out_of_range& e) {
79344       {
79345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79346       };
79347     } catch (std::exception& e) {
79348       {
79349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79350       };
79351     } catch (...) {
79352       {
79353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79354       };
79355     }
79356   }
79357 }
79358
79359
79360 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
79361   unsigned int jresult ;
79362   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79363   bool result;
79364
79365   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79366   {
79367     try {
79368       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
79369     } catch (std::out_of_range& e) {
79370       {
79371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79372       };
79373     } catch (std::exception& e) {
79374       {
79375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79376       };
79377     } catch (...) {
79378       {
79379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79380       };
79381     }
79382   }
79383   jresult = result;
79384   return jresult;
79385 }
79386
79387
79388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
79389   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79390   Dali::Actor arg2 ;
79391   Dali::Actor *argp2 ;
79392
79393   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79394   argp2 = (Dali::Actor *)jarg2;
79395   if (!argp2) {
79396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79397     return ;
79398   }
79399   arg2 = *argp2;
79400   {
79401     try {
79402       (arg1)->SetFocusIndicatorActor(arg2);
79403     } catch (std::out_of_range& e) {
79404       {
79405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79406       };
79407     } catch (std::exception& e) {
79408       {
79409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79410       };
79411     } catch (...) {
79412       {
79413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79414       };
79415     }
79416   }
79417 }
79418
79419
79420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
79421   void * jresult ;
79422   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79423   Dali::Actor result;
79424
79425   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79426   {
79427     try {
79428       result = (arg1)->GetFocusIndicatorActor();
79429     } catch (std::out_of_range& e) {
79430       {
79431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79432       };
79433     } catch (std::exception& e) {
79434       {
79435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79436       };
79437     } catch (...) {
79438       {
79439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79440       };
79441     }
79442   }
79443   jresult = new Dali::Actor((const Dali::Actor &)result);
79444   return jresult;
79445 }
79446
79447
79448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
79449   void * jresult ;
79450   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79451   Dali::Actor arg2 ;
79452   Dali::Actor *argp2 ;
79453   Dali::Actor result;
79454
79455   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79456   argp2 = (Dali::Actor *)jarg2;
79457   if (!argp2) {
79458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79459     return 0;
79460   }
79461   arg2 = *argp2;
79462   {
79463     try {
79464       result = (arg1)->GetFocusGroup(arg2);
79465     } catch (std::out_of_range& e) {
79466       {
79467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79468       };
79469     } catch (std::exception& e) {
79470       {
79471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79472       };
79473     } catch (...) {
79474       {
79475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79476       };
79477     }
79478   }
79479   jresult = new Dali::Actor((const Dali::Actor &)result);
79480   return jresult;
79481 }
79482
79483
79484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
79485   void * jresult ;
79486   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79487   Dali::Vector2 result;
79488
79489   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79490   {
79491     try {
79492       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
79493     } catch (std::out_of_range& e) {
79494       {
79495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79496       };
79497     } catch (std::exception& e) {
79498       {
79499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79500       };
79501     } catch (...) {
79502       {
79503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79504       };
79505     }
79506   }
79507   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
79508   return jresult;
79509 }
79510
79511
79512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
79513   void * jresult ;
79514   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79515   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
79516
79517   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79518   {
79519     try {
79520       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
79521     } catch (std::out_of_range& e) {
79522       {
79523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79524       };
79525     } catch (std::exception& e) {
79526       {
79527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79528       };
79529     } catch (...) {
79530       {
79531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79532       };
79533     }
79534   }
79535   jresult = (void *)result;
79536   return jresult;
79537 }
79538
79539
79540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
79541   void * jresult ;
79542   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79543   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
79544
79545   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79546   {
79547     try {
79548       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
79549     } catch (std::out_of_range& e) {
79550       {
79551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79552       };
79553     } catch (std::exception& e) {
79554       {
79555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79556       };
79557     } catch (...) {
79558       {
79559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79560       };
79561     }
79562   }
79563   jresult = (void *)result;
79564   return jresult;
79565 }
79566
79567
79568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
79569   void * jresult ;
79570   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79571   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
79572
79573   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79574   {
79575     try {
79576       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
79577     } catch (std::out_of_range& e) {
79578       {
79579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79580       };
79581     } catch (std::exception& e) {
79582       {
79583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79584       };
79585     } catch (...) {
79586       {
79587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79588       };
79589     }
79590   }
79591   jresult = (void *)result;
79592   return jresult;
79593 }
79594
79595
79596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
79597   void * jresult ;
79598   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79599   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79600
79601   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79602   {
79603     try {
79604       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
79605     } catch (std::out_of_range& e) {
79606       {
79607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79608       };
79609     } catch (std::exception& e) {
79610       {
79611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79612       };
79613     } catch (...) {
79614       {
79615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79616       };
79617     }
79618   }
79619   jresult = (void *)result;
79620   return jresult;
79621 }
79622
79623
79624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
79625   void * jresult ;
79626   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79627   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79628
79629   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79630   {
79631     try {
79632       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
79633     } catch (std::out_of_range& e) {
79634       {
79635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79636       };
79637     } catch (std::exception& e) {
79638       {
79639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79640       };
79641     } catch (...) {
79642       {
79643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79644       };
79645     }
79646   }
79647   jresult = (void *)result;
79648   return jresult;
79649 }
79650
79651
79652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
79653   void * jresult ;
79654   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79655   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79656
79657   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79658   {
79659     try {
79660       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
79661     } catch (std::out_of_range& e) {
79662       {
79663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79664       };
79665     } catch (std::exception& e) {
79666       {
79667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79668       };
79669     } catch (...) {
79670       {
79671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79672       };
79673     }
79674   }
79675   jresult = (void *)result;
79676   return jresult;
79677 }
79678
79679
79680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
79681   void * jresult ;
79682   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79683   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79684
79685   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79686   {
79687     try {
79688       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
79689     } catch (std::out_of_range& e) {
79690       {
79691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79692       };
79693     } catch (std::exception& e) {
79694       {
79695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79696       };
79697     } catch (...) {
79698       {
79699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79700       };
79701     }
79702   }
79703   jresult = (void *)result;
79704   return jresult;
79705 }
79706
79707
79708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
79709   void * jresult ;
79710   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79711   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79712
79713   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79714   {
79715     try {
79716       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
79717     } catch (std::out_of_range& e) {
79718       {
79719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79720       };
79721     } catch (std::exception& e) {
79722       {
79723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79724       };
79725     } catch (...) {
79726       {
79727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79728       };
79729     }
79730   }
79731   jresult = (void *)result;
79732   return jresult;
79733 }
79734
79735
79736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
79737   void * jresult ;
79738   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79739   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79740
79741   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79742   {
79743     try {
79744       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
79745     } catch (std::out_of_range& e) {
79746       {
79747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79748       };
79749     } catch (std::exception& e) {
79750       {
79751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79752       };
79753     } catch (...) {
79754       {
79755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79756       };
79757     }
79758   }
79759   jresult = (void *)result;
79760   return jresult;
79761 }
79762
79763
79764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
79765   void * jresult ;
79766   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79767   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79768
79769   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79770   {
79771     try {
79772       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
79773     } catch (std::out_of_range& e) {
79774       {
79775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79776       };
79777     } catch (std::exception& e) {
79778       {
79779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79780       };
79781     } catch (...) {
79782       {
79783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79784       };
79785     }
79786   }
79787   jresult = (void *)result;
79788   return jresult;
79789 }
79790
79791
79792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
79793   void * jresult ;
79794   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79795   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79796
79797   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79798   {
79799     try {
79800       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
79801     } catch (std::out_of_range& e) {
79802       {
79803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79804       };
79805     } catch (std::exception& e) {
79806       {
79807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79808       };
79809     } catch (...) {
79810       {
79811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79812       };
79813     }
79814   }
79815   jresult = (void *)result;
79816   return jresult;
79817 }
79818
79819
79820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
79821   void * jresult ;
79822   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79823   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79824
79825   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79826   {
79827     try {
79828       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
79829     } catch (std::out_of_range& e) {
79830       {
79831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79832       };
79833     } catch (std::exception& e) {
79834       {
79835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79836       };
79837     } catch (...) {
79838       {
79839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79840       };
79841     }
79842   }
79843   jresult = (void *)result;
79844   return jresult;
79845 }
79846
79847
79848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
79849   void * jresult ;
79850   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79851   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79852
79853   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79854   {
79855     try {
79856       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
79857     } catch (std::out_of_range& e) {
79858       {
79859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79860       };
79861     } catch (std::exception& e) {
79862       {
79863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79864       };
79865     } catch (...) {
79866       {
79867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79868       };
79869     }
79870   }
79871   jresult = (void *)result;
79872   return jresult;
79873 }
79874
79875
79876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
79877   void * jresult ;
79878   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79879   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79880
79881   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79882   {
79883     try {
79884       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
79885     } catch (std::out_of_range& e) {
79886       {
79887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79888       };
79889     } catch (std::exception& e) {
79890       {
79891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79892       };
79893     } catch (...) {
79894       {
79895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79896       };
79897     }
79898   }
79899   jresult = (void *)result;
79900   return jresult;
79901 }
79902
79903
79904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
79905   void * jresult ;
79906   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79907   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79908
79909   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79910   {
79911     try {
79912       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
79913     } catch (std::out_of_range& e) {
79914       {
79915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79916       };
79917     } catch (std::exception& e) {
79918       {
79919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79920       };
79921     } catch (...) {
79922       {
79923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79924       };
79925     }
79926   }
79927   jresult = (void *)result;
79928   return jresult;
79929 }
79930
79931
79932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
79933   void * jresult ;
79934   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79935   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79936
79937   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79938   {
79939     try {
79940       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
79941     } catch (std::out_of_range& e) {
79942       {
79943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79944       };
79945     } catch (std::exception& e) {
79946       {
79947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79948       };
79949     } catch (...) {
79950       {
79951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79952       };
79953     }
79954   }
79955   jresult = (void *)result;
79956   return jresult;
79957 }
79958
79959
79960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
79961   void * jresult ;
79962   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79963   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79964
79965   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79966   {
79967     try {
79968       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
79969     } catch (std::out_of_range& e) {
79970       {
79971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79972       };
79973     } catch (std::exception& e) {
79974       {
79975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79976       };
79977     } catch (...) {
79978       {
79979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79980       };
79981     }
79982   }
79983   jresult = (void *)result;
79984   return jresult;
79985 }
79986
79987
79988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
79989   void * jresult ;
79990   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79991   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79992
79993   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79994   {
79995     try {
79996       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
79997     } catch (std::out_of_range& e) {
79998       {
79999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80000       };
80001     } catch (std::exception& e) {
80002       {
80003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80004       };
80005     } catch (...) {
80006       {
80007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80008       };
80009     }
80010   }
80011   jresult = (void *)result;
80012   return jresult;
80013 }
80014
80015
80016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
80017   void * jresult ;
80018   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80019   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80020
80021   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80022   {
80023     try {
80024       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
80025     } catch (std::out_of_range& e) {
80026       {
80027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80028       };
80029     } catch (std::exception& e) {
80030       {
80031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80032       };
80033     } catch (...) {
80034       {
80035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80036       };
80037     }
80038   }
80039   jresult = (void *)result;
80040   return jresult;
80041 }
80042
80043
80044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
80045   void * jresult ;
80046   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80047   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80048
80049   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80050   {
80051     try {
80052       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
80053     } catch (std::out_of_range& e) {
80054       {
80055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80056       };
80057     } catch (std::exception& e) {
80058       {
80059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80060       };
80061     } catch (...) {
80062       {
80063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80064       };
80065     }
80066   }
80067   jresult = (void *)result;
80068   return jresult;
80069 }
80070
80071
80072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
80073   void * jresult ;
80074   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80075   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80076
80077   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80078   {
80079     try {
80080       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
80081     } catch (std::out_of_range& e) {
80082       {
80083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80084       };
80085     } catch (std::exception& e) {
80086       {
80087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80088       };
80089     } catch (...) {
80090       {
80091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80092       };
80093     }
80094   }
80095   jresult = (void *)result;
80096   return jresult;
80097 }
80098
80099
80100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
80101   void * jresult ;
80102   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80103   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80104
80105   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80106   {
80107     try {
80108       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
80109     } catch (std::out_of_range& e) {
80110       {
80111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80112       };
80113     } catch (std::exception& e) {
80114       {
80115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80116       };
80117     } catch (...) {
80118       {
80119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80120       };
80121     }
80122   }
80123   jresult = (void *)result;
80124   return jresult;
80125 }
80126
80127
80128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
80129   void * jresult ;
80130   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80131   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80132
80133   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80134   {
80135     try {
80136       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
80137     } catch (std::out_of_range& e) {
80138       {
80139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80140       };
80141     } catch (std::exception& e) {
80142       {
80143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80144       };
80145     } catch (...) {
80146       {
80147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80148       };
80149     }
80150   }
80151   jresult = (void *)result;
80152   return jresult;
80153 }
80154
80155
80156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
80157   void * jresult ;
80158   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80159   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80160
80161   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80162   {
80163     try {
80164       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
80165     } catch (std::out_of_range& e) {
80166       {
80167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80168       };
80169     } catch (std::exception& e) {
80170       {
80171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80172       };
80173     } catch (...) {
80174       {
80175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80176       };
80177     }
80178   }
80179   jresult = (void *)result;
80180   return jresult;
80181 }
80182
80183
80184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
80185   void * jresult ;
80186   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80187   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80188
80189   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80190   {
80191     try {
80192       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
80193     } catch (std::out_of_range& e) {
80194       {
80195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80196       };
80197     } catch (std::exception& e) {
80198       {
80199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80200       };
80201     } catch (...) {
80202       {
80203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80204       };
80205     }
80206   }
80207   jresult = (void *)result;
80208   return jresult;
80209 }
80210
80211
80212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
80213   void * jresult ;
80214   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80215   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80216
80217   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80218   {
80219     try {
80220       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
80221     } catch (std::out_of_range& e) {
80222       {
80223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80224       };
80225     } catch (std::exception& e) {
80226       {
80227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80228       };
80229     } catch (...) {
80230       {
80231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80232       };
80233     }
80234   }
80235   jresult = (void *)result;
80236   return jresult;
80237 }
80238
80239
80240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
80241   void * jresult ;
80242   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80243   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80244
80245   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80246   {
80247     try {
80248       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
80249     } catch (std::out_of_range& e) {
80250       {
80251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80252       };
80253     } catch (std::exception& e) {
80254       {
80255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80256       };
80257     } catch (...) {
80258       {
80259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80260       };
80261     }
80262   }
80263   jresult = (void *)result;
80264   return jresult;
80265 }
80266
80267
80268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
80269   void * jresult ;
80270   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80271   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80272
80273   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80274   {
80275     try {
80276       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
80277     } catch (std::out_of_range& e) {
80278       {
80279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80280       };
80281     } catch (std::exception& e) {
80282       {
80283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80284       };
80285     } catch (...) {
80286       {
80287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80288       };
80289     }
80290   }
80291   jresult = (void *)result;
80292   return jresult;
80293 }
80294
80295
80296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
80297   void * jresult ;
80298   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80299   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80300
80301   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80302   {
80303     try {
80304       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
80305     } catch (std::out_of_range& e) {
80306       {
80307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80308       };
80309     } catch (std::exception& e) {
80310       {
80311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80312       };
80313     } catch (...) {
80314       {
80315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80316       };
80317     }
80318   }
80319   jresult = (void *)result;
80320   return jresult;
80321 }
80322
80323
80324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
80325   void * jresult ;
80326   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80327   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
80328
80329   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80330   {
80331     try {
80332       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
80333     } catch (std::out_of_range& e) {
80334       {
80335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80336       };
80337     } catch (std::exception& e) {
80338       {
80339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80340       };
80341     } catch (...) {
80342       {
80343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80344       };
80345     }
80346   }
80347   jresult = (void *)result;
80348   return jresult;
80349 }
80350
80351
80352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
80353   void * jresult ;
80354   Dali::Toolkit::StyleManager *result = 0 ;
80355
80356   {
80357     try {
80358       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
80359     } catch (std::out_of_range& e) {
80360       {
80361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80362       };
80363     } catch (std::exception& e) {
80364       {
80365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80366       };
80367     } catch (...) {
80368       {
80369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80370       };
80371     }
80372   }
80373   jresult = (void *)result;
80374   return jresult;
80375 }
80376
80377
80378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
80379   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80380
80381   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80382   {
80383     try {
80384       delete arg1;
80385     } catch (std::out_of_range& e) {
80386       {
80387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80388       };
80389     } catch (std::exception& e) {
80390       {
80391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80392       };
80393     } catch (...) {
80394       {
80395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80396       };
80397     }
80398   }
80399 }
80400
80401
80402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
80403   void * jresult ;
80404   Dali::Toolkit::StyleManager result;
80405
80406   {
80407     try {
80408       result = Dali::Toolkit::StyleManager::Get();
80409     } catch (std::out_of_range& e) {
80410       {
80411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80412       };
80413     } catch (std::exception& e) {
80414       {
80415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80416       };
80417     } catch (...) {
80418       {
80419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80420       };
80421     }
80422   }
80423   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
80424   return jresult;
80425 }
80426
80427
80428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
80429   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80430   std::string *arg2 = 0 ;
80431
80432   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80433   if (!jarg2) {
80434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80435     return ;
80436   }
80437   std::string arg2_str(jarg2);
80438   arg2 = &arg2_str;
80439   {
80440     try {
80441       (arg1)->ApplyTheme((std::string const &)*arg2);
80442     } catch (std::out_of_range& e) {
80443       {
80444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80445       };
80446     } catch (std::exception& e) {
80447       {
80448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80449       };
80450     } catch (...) {
80451       {
80452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80453       };
80454     }
80455   }
80456
80457   //argout typemap for const std::string&
80458
80459 }
80460
80461
80462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
80463   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80464
80465   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80466   {
80467     try {
80468       (arg1)->ApplyDefaultTheme();
80469     } catch (std::out_of_range& e) {
80470       {
80471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80472       };
80473     } catch (std::exception& e) {
80474       {
80475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80476       };
80477     } catch (...) {
80478       {
80479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80480       };
80481     }
80482   }
80483 }
80484
80485
80486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
80487   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80488   std::string *arg2 = 0 ;
80489   Dali::Property::Value *arg3 = 0 ;
80490
80491   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80492   if (!jarg2) {
80493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80494     return ;
80495   }
80496   std::string arg2_str(jarg2);
80497   arg2 = &arg2_str;
80498   arg3 = (Dali::Property::Value *)jarg3;
80499   if (!arg3) {
80500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
80501     return ;
80502   }
80503   {
80504     try {
80505       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
80506     } catch (std::out_of_range& e) {
80507       {
80508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80509       };
80510     } catch (std::exception& e) {
80511       {
80512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80513       };
80514     } catch (...) {
80515       {
80516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80517       };
80518     }
80519   }
80520
80521   //argout typemap for const std::string&
80522
80523 }
80524
80525
80526 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
80527   unsigned int jresult ;
80528   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80529   std::string *arg2 = 0 ;
80530   Dali::Property::Value *arg3 = 0 ;
80531   bool result;
80532
80533   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80534   if (!jarg2) {
80535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80536     return 0;
80537   }
80538   std::string arg2_str(jarg2);
80539   arg2 = &arg2_str;
80540   arg3 = (Dali::Property::Value *)jarg3;
80541   if (!arg3) {
80542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
80543     return 0;
80544   }
80545   {
80546     try {
80547       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
80548     } catch (std::out_of_range& e) {
80549       {
80550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80551       };
80552     } catch (std::exception& e) {
80553       {
80554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80555       };
80556     } catch (...) {
80557       {
80558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80559       };
80560     }
80561   }
80562   jresult = result;
80563
80564   //argout typemap for const std::string&
80565
80566   return jresult;
80567 }
80568
80569
80570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
80571   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80572   Dali::Toolkit::Control arg2 ;
80573   std::string *arg3 = 0 ;
80574   std::string *arg4 = 0 ;
80575   Dali::Toolkit::Control *argp2 ;
80576
80577   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80578   argp2 = (Dali::Toolkit::Control *)jarg2;
80579   if (!argp2) {
80580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
80581     return ;
80582   }
80583   arg2 = *argp2;
80584   if (!jarg3) {
80585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80586     return ;
80587   }
80588   std::string arg3_str(jarg3);
80589   arg3 = &arg3_str;
80590   if (!jarg4) {
80591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80592     return ;
80593   }
80594   std::string arg4_str(jarg4);
80595   arg4 = &arg4_str;
80596   {
80597     try {
80598       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
80599     } catch (std::out_of_range& e) {
80600       {
80601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80602       };
80603     } catch (std::exception& e) {
80604       {
80605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80606       };
80607     } catch (...) {
80608       {
80609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80610       };
80611     }
80612   }
80613
80614   //argout typemap for const std::string&
80615
80616
80617   //argout typemap for const std::string&
80618
80619 }
80620
80621
80622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
80623   void * jresult ;
80624   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80625   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
80626
80627   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80628   {
80629     try {
80630       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
80631     } catch (std::out_of_range& e) {
80632       {
80633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80634       };
80635     } catch (std::exception& e) {
80636       {
80637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80638       };
80639     } catch (...) {
80640       {
80641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80642       };
80643     }
80644   }
80645   jresult = (void *)result;
80646   return jresult;
80647 }
80648
80649
80650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
80651   int jresult ;
80652   int result;
80653
80654   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
80655   jresult = (int)result;
80656   return jresult;
80657 }
80658
80659
80660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
80661   int jresult ;
80662   int result;
80663
80664   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
80665   jresult = (int)result;
80666   return jresult;
80667 }
80668
80669
80670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
80671   int jresult ;
80672   int result;
80673
80674   result = (int)Dali::Toolkit::Slider::Property::VALUE;
80675   jresult = (int)result;
80676   return jresult;
80677 }
80678
80679
80680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
80681   int jresult ;
80682   int result;
80683
80684   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
80685   jresult = (int)result;
80686   return jresult;
80687 }
80688
80689
80690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
80691   int jresult ;
80692   int result;
80693
80694   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
80695   jresult = (int)result;
80696   return jresult;
80697 }
80698
80699
80700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
80701   int jresult ;
80702   int result;
80703
80704   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
80705   jresult = (int)result;
80706   return jresult;
80707 }
80708
80709
80710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
80711   int jresult ;
80712   int result;
80713
80714   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
80715   jresult = (int)result;
80716   return jresult;
80717 }
80718
80719
80720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
80721   int jresult ;
80722   int result;
80723
80724   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
80725   jresult = (int)result;
80726   return jresult;
80727 }
80728
80729
80730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
80731   int jresult ;
80732   int result;
80733
80734   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
80735   jresult = (int)result;
80736   return jresult;
80737 }
80738
80739
80740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
80741   int jresult ;
80742   int result;
80743
80744   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
80745   jresult = (int)result;
80746   return jresult;
80747 }
80748
80749
80750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
80751   int jresult ;
80752   int result;
80753
80754   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
80755   jresult = (int)result;
80756   return jresult;
80757 }
80758
80759
80760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
80761   int jresult ;
80762   int result;
80763
80764   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
80765   jresult = (int)result;
80766   return jresult;
80767 }
80768
80769
80770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
80771   int jresult ;
80772   int result;
80773
80774   result = (int)Dali::Toolkit::Slider::Property::MARKS;
80775   jresult = (int)result;
80776   return jresult;
80777 }
80778
80779
80780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
80781   int jresult ;
80782   int result;
80783
80784   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
80785   jresult = (int)result;
80786   return jresult;
80787 }
80788
80789
80790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
80791   int jresult ;
80792   int result;
80793
80794   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
80795   jresult = (int)result;
80796   return jresult;
80797 }
80798
80799
80800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
80801   void * jresult ;
80802   Dali::Toolkit::Slider::Property *result = 0 ;
80803
80804   {
80805     try {
80806       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
80807     } catch (std::out_of_range& e) {
80808       {
80809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80810       };
80811     } catch (std::exception& e) {
80812       {
80813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80814       };
80815     } catch (...) {
80816       {
80817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80818       };
80819     }
80820   }
80821   jresult = (void *)result;
80822   return jresult;
80823 }
80824
80825
80826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
80827   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
80828
80829   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
80830   {
80831     try {
80832       delete arg1;
80833     } catch (std::out_of_range& e) {
80834       {
80835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80836       };
80837     } catch (std::exception& e) {
80838       {
80839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80840       };
80841     } catch (...) {
80842       {
80843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80844       };
80845     }
80846   }
80847 }
80848
80849
80850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
80851   void * jresult ;
80852   Dali::Toolkit::Slider result;
80853
80854   {
80855     try {
80856       result = Dali::Toolkit::Slider::New();
80857     } catch (std::out_of_range& e) {
80858       {
80859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80860       };
80861     } catch (std::exception& e) {
80862       {
80863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80864       };
80865     } catch (...) {
80866       {
80867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80868       };
80869     }
80870   }
80871   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
80872   return jresult;
80873 }
80874
80875
80876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
80877   void * jresult ;
80878   Dali::Toolkit::Slider *result = 0 ;
80879
80880   {
80881     try {
80882       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
80883     } catch (std::out_of_range& e) {
80884       {
80885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80886       };
80887     } catch (std::exception& e) {
80888       {
80889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80890       };
80891     } catch (...) {
80892       {
80893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80894       };
80895     }
80896   }
80897   jresult = (void *)result;
80898   return jresult;
80899 }
80900
80901
80902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
80903   void * jresult ;
80904   Dali::Toolkit::Slider *arg1 = 0 ;
80905   Dali::Toolkit::Slider *result = 0 ;
80906
80907   arg1 = (Dali::Toolkit::Slider *)jarg1;
80908   if (!arg1) {
80909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
80910     return 0;
80911   }
80912   {
80913     try {
80914       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
80915     } catch (std::out_of_range& e) {
80916       {
80917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80918       };
80919     } catch (std::exception& e) {
80920       {
80921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80922       };
80923     } catch (...) {
80924       {
80925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80926       };
80927     }
80928   }
80929   jresult = (void *)result;
80930   return jresult;
80931 }
80932
80933
80934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
80935   void * jresult ;
80936   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
80937   Dali::Toolkit::Slider *arg2 = 0 ;
80938   Dali::Toolkit::Slider *result = 0 ;
80939
80940   arg1 = (Dali::Toolkit::Slider *)jarg1;
80941   arg2 = (Dali::Toolkit::Slider *)jarg2;
80942   if (!arg2) {
80943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
80944     return 0;
80945   }
80946   {
80947     try {
80948       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
80949     } catch (std::out_of_range& e) {
80950       {
80951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80952       };
80953     } catch (std::exception& e) {
80954       {
80955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80956       };
80957     } catch (...) {
80958       {
80959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80960       };
80961     }
80962   }
80963   jresult = (void *)result;
80964   return jresult;
80965 }
80966
80967
80968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
80969   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
80970
80971   arg1 = (Dali::Toolkit::Slider *)jarg1;
80972   {
80973     try {
80974       delete arg1;
80975     } catch (std::out_of_range& e) {
80976       {
80977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80978       };
80979     } catch (std::exception& e) {
80980       {
80981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80982       };
80983     } catch (...) {
80984       {
80985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80986       };
80987     }
80988   }
80989 }
80990
80991
80992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
80993   void * jresult ;
80994   Dali::BaseHandle arg1 ;
80995   Dali::BaseHandle *argp1 ;
80996   Dali::Toolkit::Slider result;
80997
80998   argp1 = (Dali::BaseHandle *)jarg1;
80999   if (!argp1) {
81000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81001     return 0;
81002   }
81003   arg1 = *argp1;
81004   {
81005     try {
81006       result = Dali::Toolkit::Slider::DownCast(arg1);
81007     } catch (std::out_of_range& e) {
81008       {
81009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81010       };
81011     } catch (std::exception& e) {
81012       {
81013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81014       };
81015     } catch (...) {
81016       {
81017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81018       };
81019     }
81020   }
81021   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81022   return jresult;
81023 }
81024
81025
81026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
81027   void * jresult ;
81028   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81029   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81030
81031   arg1 = (Dali::Toolkit::Slider *)jarg1;
81032   {
81033     try {
81034       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
81035     } catch (std::out_of_range& e) {
81036       {
81037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81038       };
81039     } catch (std::exception& e) {
81040       {
81041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81042       };
81043     } catch (...) {
81044       {
81045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81046       };
81047     }
81048   }
81049   jresult = (void *)result;
81050   return jresult;
81051 }
81052
81053
81054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
81055   void * jresult ;
81056   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81057   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81058
81059   arg1 = (Dali::Toolkit::Slider *)jarg1;
81060   {
81061     try {
81062       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
81063     } catch (std::out_of_range& e) {
81064       {
81065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81066       };
81067     } catch (std::exception& e) {
81068       {
81069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81070       };
81071     } catch (...) {
81072       {
81073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81074       };
81075     }
81076   }
81077   jresult = (void *)result;
81078   return jresult;
81079 }
81080
81081
81082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
81083   void * jresult ;
81084   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81085   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
81086
81087   arg1 = (Dali::Toolkit::Slider *)jarg1;
81088   {
81089     try {
81090       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
81091     } catch (std::out_of_range& e) {
81092       {
81093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81094       };
81095     } catch (std::exception& e) {
81096       {
81097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81098       };
81099     } catch (...) {
81100       {
81101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81102       };
81103     }
81104   }
81105   jresult = (void *)result;
81106   return jresult;
81107 }
81108
81109
81110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
81111   int jresult ;
81112   int result;
81113
81114   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
81115   jresult = (int)result;
81116   return jresult;
81117 }
81118
81119
81120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
81121   int jresult ;
81122   int result;
81123
81124   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
81125   jresult = (int)result;
81126   return jresult;
81127 }
81128
81129
81130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
81131   int jresult ;
81132   int result;
81133
81134   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
81135   jresult = (int)result;
81136   return jresult;
81137 }
81138
81139
81140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
81141   int jresult ;
81142   int result;
81143
81144   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
81145   jresult = (int)result;
81146   return jresult;
81147 }
81148
81149
81150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
81151   void * jresult ;
81152   Dali::Toolkit::VideoView::Property *result = 0 ;
81153
81154   {
81155     try {
81156       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
81157     } catch (std::out_of_range& e) {
81158       {
81159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81160       };
81161     } catch (std::exception& e) {
81162       {
81163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81164       };
81165     } catch (...) {
81166       {
81167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81168       };
81169     }
81170   }
81171   jresult = (void *)result;
81172   return jresult;
81173 }
81174
81175
81176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
81177   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
81178
81179   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
81180   {
81181     try {
81182       delete arg1;
81183     } catch (std::out_of_range& e) {
81184       {
81185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81186       };
81187     } catch (std::exception& e) {
81188       {
81189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81190       };
81191     } catch (...) {
81192       {
81193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81194       };
81195     }
81196   }
81197 }
81198
81199
81200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
81201   void * jresult ;
81202   Dali::Toolkit::VideoView result;
81203
81204   {
81205     try {
81206       result = Dali::Toolkit::VideoView::New();
81207     } catch (std::out_of_range& e) {
81208       {
81209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81210       };
81211     } catch (std::exception& e) {
81212       {
81213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81214       };
81215     } catch (...) {
81216       {
81217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81218       };
81219     }
81220   }
81221   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81222   return jresult;
81223 }
81224
81225
81226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
81227   void * jresult ;
81228   std::string *arg1 = 0 ;
81229   Dali::Toolkit::VideoView result;
81230
81231   if (!jarg1) {
81232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81233     return 0;
81234   }
81235   std::string arg1_str(jarg1);
81236   arg1 = &arg1_str;
81237   {
81238     try {
81239       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
81240     } catch (std::out_of_range& e) {
81241       {
81242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81243       };
81244     } catch (std::exception& e) {
81245       {
81246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81247       };
81248     } catch (...) {
81249       {
81250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81251       };
81252     }
81253   }
81254   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81255
81256   //argout typemap for const std::string&
81257
81258   return jresult;
81259 }
81260
81261
81262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
81263   void * jresult ;
81264   Dali::Toolkit::VideoView *result = 0 ;
81265
81266   {
81267     try {
81268       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
81269     } catch (std::out_of_range& e) {
81270       {
81271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81272       };
81273     } catch (std::exception& e) {
81274       {
81275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81276       };
81277     } catch (...) {
81278       {
81279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81280       };
81281     }
81282   }
81283   jresult = (void *)result;
81284   return jresult;
81285 }
81286
81287
81288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
81289   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81290
81291   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81292   {
81293     try {
81294       delete arg1;
81295     } catch (std::out_of_range& e) {
81296       {
81297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81298       };
81299     } catch (std::exception& e) {
81300       {
81301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81302       };
81303     } catch (...) {
81304       {
81305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81306       };
81307     }
81308   }
81309 }
81310
81311
81312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
81313   void * jresult ;
81314   Dali::Toolkit::VideoView *arg1 = 0 ;
81315   Dali::Toolkit::VideoView *result = 0 ;
81316
81317   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81318   if (!arg1) {
81319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
81320     return 0;
81321   }
81322   {
81323     try {
81324       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
81325     } catch (std::out_of_range& e) {
81326       {
81327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81328       };
81329     } catch (std::exception& e) {
81330       {
81331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81332       };
81333     } catch (...) {
81334       {
81335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81336       };
81337     }
81338   }
81339   jresult = (void *)result;
81340   return jresult;
81341 }
81342
81343
81344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
81345   void * jresult ;
81346   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81347   Dali::Toolkit::VideoView *arg2 = 0 ;
81348   Dali::Toolkit::VideoView *result = 0 ;
81349
81350   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81351   arg2 = (Dali::Toolkit::VideoView *)jarg2;
81352   if (!arg2) {
81353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
81354     return 0;
81355   }
81356   {
81357     try {
81358       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
81359     } catch (std::out_of_range& e) {
81360       {
81361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81362       };
81363     } catch (std::exception& e) {
81364       {
81365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81366       };
81367     } catch (...) {
81368       {
81369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81370       };
81371     }
81372   }
81373   jresult = (void *)result;
81374   return jresult;
81375 }
81376
81377
81378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
81379   void * jresult ;
81380   Dali::BaseHandle arg1 ;
81381   Dali::BaseHandle *argp1 ;
81382   Dali::Toolkit::VideoView result;
81383
81384   argp1 = (Dali::BaseHandle *)jarg1;
81385   if (!argp1) {
81386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81387     return 0;
81388   }
81389   arg1 = *argp1;
81390   {
81391     try {
81392       result = Dali::Toolkit::VideoView::DownCast(arg1);
81393     } catch (std::out_of_range& e) {
81394       {
81395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81396       };
81397     } catch (std::exception& e) {
81398       {
81399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81400       };
81401     } catch (...) {
81402       {
81403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81404       };
81405     }
81406   }
81407   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81408   return jresult;
81409 }
81410
81411
81412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
81413   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81414
81415   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81416   {
81417     try {
81418       (arg1)->Play();
81419     } catch (std::out_of_range& e) {
81420       {
81421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81422       };
81423     } catch (std::exception& e) {
81424       {
81425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81426       };
81427     } catch (...) {
81428       {
81429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81430       };
81431     }
81432   }
81433 }
81434
81435
81436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
81437   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81438
81439   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81440   {
81441     try {
81442       (arg1)->Pause();
81443     } catch (std::out_of_range& e) {
81444       {
81445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81446       };
81447     } catch (std::exception& e) {
81448       {
81449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81450       };
81451     } catch (...) {
81452       {
81453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81454       };
81455     }
81456   }
81457 }
81458
81459
81460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
81461   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81462
81463   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81464   {
81465     try {
81466       (arg1)->Stop();
81467     } catch (std::out_of_range& e) {
81468       {
81469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81470       };
81471     } catch (std::exception& e) {
81472       {
81473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81474       };
81475     } catch (...) {
81476       {
81477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81478       };
81479     }
81480   }
81481 }
81482
81483
81484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
81485   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81486   int arg2 ;
81487
81488   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81489   arg2 = (int)jarg2;
81490   {
81491     try {
81492       (arg1)->Forward(arg2);
81493     } catch (std::out_of_range& e) {
81494       {
81495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81496       };
81497     } catch (std::exception& e) {
81498       {
81499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81500       };
81501     } catch (...) {
81502       {
81503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81504       };
81505     }
81506   }
81507 }
81508
81509
81510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
81511   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81512   int arg2 ;
81513
81514   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81515   arg2 = (int)jarg2;
81516   {
81517     try {
81518       (arg1)->Backward(arg2);
81519     } catch (std::out_of_range& e) {
81520       {
81521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81522       };
81523     } catch (std::exception& e) {
81524       {
81525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81526       };
81527     } catch (...) {
81528       {
81529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81530       };
81531     }
81532   }
81533 }
81534
81535
81536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
81537   void * jresult ;
81538   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81539   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
81540
81541   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81542   {
81543     try {
81544       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
81545     } catch (std::out_of_range& e) {
81546       {
81547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81548       };
81549     } catch (std::exception& e) {
81550       {
81551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81552       };
81553     } catch (...) {
81554       {
81555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81556       };
81557     }
81558   }
81559   jresult = (void *)result;
81560   return jresult;
81561 }
81562
81563
81564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
81565   int jresult ;
81566   int result;
81567
81568   result = (int)Dali::Toolkit::Popup::Property::TITLE;
81569   jresult = (int)result;
81570   return jresult;
81571 }
81572
81573
81574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
81575   int jresult ;
81576   int result;
81577
81578   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
81579   jresult = (int)result;
81580   return jresult;
81581 }
81582
81583
81584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
81585   int jresult ;
81586   int result;
81587
81588   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
81589   jresult = (int)result;
81590   return jresult;
81591 }
81592
81593
81594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
81595   int jresult ;
81596   int result;
81597
81598   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
81599   jresult = (int)result;
81600   return jresult;
81601 }
81602
81603
81604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
81605   int jresult ;
81606   int result;
81607
81608   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
81609   jresult = (int)result;
81610   return jresult;
81611 }
81612
81613
81614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
81615   int jresult ;
81616   int result;
81617
81618   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
81619   jresult = (int)result;
81620   return jresult;
81621 }
81622
81623
81624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
81625   int jresult ;
81626   int result;
81627
81628   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
81629   jresult = (int)result;
81630   return jresult;
81631 }
81632
81633
81634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
81635   int jresult ;
81636   int result;
81637
81638   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
81639   jresult = (int)result;
81640   return jresult;
81641 }
81642
81643
81644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
81645   int jresult ;
81646   int result;
81647
81648   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
81649   jresult = (int)result;
81650   return jresult;
81651 }
81652
81653
81654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
81655   int jresult ;
81656   int result;
81657
81658   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
81659   jresult = (int)result;
81660   return jresult;
81661 }
81662
81663
81664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
81665   int jresult ;
81666   int result;
81667
81668   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
81669   jresult = (int)result;
81670   return jresult;
81671 }
81672
81673
81674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
81675   int jresult ;
81676   int result;
81677
81678   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
81679   jresult = (int)result;
81680   return jresult;
81681 }
81682
81683
81684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
81685   int jresult ;
81686   int result;
81687
81688   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
81689   jresult = (int)result;
81690   return jresult;
81691 }
81692
81693
81694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
81695   int jresult ;
81696   int result;
81697
81698   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
81699   jresult = (int)result;
81700   return jresult;
81701 }
81702
81703
81704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
81705   int jresult ;
81706   int result;
81707
81708   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
81709   jresult = (int)result;
81710   return jresult;
81711 }
81712
81713
81714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
81715   int jresult ;
81716   int result;
81717
81718   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
81719   jresult = (int)result;
81720   return jresult;
81721 }
81722
81723
81724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
81725   int jresult ;
81726   int result;
81727
81728   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
81729   jresult = (int)result;
81730   return jresult;
81731 }
81732
81733
81734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
81735   int jresult ;
81736   int result;
81737
81738   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
81739   jresult = (int)result;
81740   return jresult;
81741 }
81742
81743
81744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
81745   int jresult ;
81746   int result;
81747
81748   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
81749   jresult = (int)result;
81750   return jresult;
81751 }
81752
81753
81754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
81755   int jresult ;
81756   int result;
81757
81758   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
81759   jresult = (int)result;
81760   return jresult;
81761 }
81762
81763
81764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
81765   int jresult ;
81766   int result;
81767
81768   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
81769   jresult = (int)result;
81770   return jresult;
81771 }
81772
81773
81774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
81775   void * jresult ;
81776   Dali::Toolkit::Popup::Property *result = 0 ;
81777
81778   {
81779     try {
81780       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
81781     } catch (std::out_of_range& e) {
81782       {
81783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81784       };
81785     } catch (std::exception& e) {
81786       {
81787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81788       };
81789     } catch (...) {
81790       {
81791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81792       };
81793     }
81794   }
81795   jresult = (void *)result;
81796   return jresult;
81797 }
81798
81799
81800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
81801   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
81802
81803   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
81804   {
81805     try {
81806       delete arg1;
81807     } catch (std::out_of_range& e) {
81808       {
81809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81810       };
81811     } catch (std::exception& e) {
81812       {
81813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81814       };
81815     } catch (...) {
81816       {
81817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81818       };
81819     }
81820   }
81821 }
81822
81823
81824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
81825   void * jresult ;
81826   Dali::Toolkit::Popup *result = 0 ;
81827
81828   {
81829     try {
81830       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
81831     } catch (std::out_of_range& e) {
81832       {
81833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81834       };
81835     } catch (std::exception& e) {
81836       {
81837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81838       };
81839     } catch (...) {
81840       {
81841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81842       };
81843     }
81844   }
81845   jresult = (void *)result;
81846   return jresult;
81847 }
81848
81849
81850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
81851   void * jresult ;
81852   Dali::Toolkit::Popup result;
81853
81854   {
81855     try {
81856       result = Dali::Toolkit::Popup::New();
81857     } catch (std::out_of_range& e) {
81858       {
81859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81860       };
81861     } catch (std::exception& e) {
81862       {
81863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81864       };
81865     } catch (...) {
81866       {
81867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81868       };
81869     }
81870   }
81871   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
81872   return jresult;
81873 }
81874
81875
81876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
81877   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81878
81879   arg1 = (Dali::Toolkit::Popup *)jarg1;
81880   {
81881     try {
81882       delete arg1;
81883     } catch (std::out_of_range& e) {
81884       {
81885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81886       };
81887     } catch (std::exception& e) {
81888       {
81889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81890       };
81891     } catch (...) {
81892       {
81893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81894       };
81895     }
81896   }
81897 }
81898
81899
81900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
81901   void * jresult ;
81902   Dali::Toolkit::Popup *arg1 = 0 ;
81903   Dali::Toolkit::Popup *result = 0 ;
81904
81905   arg1 = (Dali::Toolkit::Popup *)jarg1;
81906   if (!arg1) {
81907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
81908     return 0;
81909   }
81910   {
81911     try {
81912       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
81913     } catch (std::out_of_range& e) {
81914       {
81915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81916       };
81917     } catch (std::exception& e) {
81918       {
81919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81920       };
81921     } catch (...) {
81922       {
81923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81924       };
81925     }
81926   }
81927   jresult = (void *)result;
81928   return jresult;
81929 }
81930
81931
81932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
81933   void * jresult ;
81934   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81935   Dali::Toolkit::Popup *arg2 = 0 ;
81936   Dali::Toolkit::Popup *result = 0 ;
81937
81938   arg1 = (Dali::Toolkit::Popup *)jarg1;
81939   arg2 = (Dali::Toolkit::Popup *)jarg2;
81940   if (!arg2) {
81941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
81942     return 0;
81943   }
81944   {
81945     try {
81946       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
81947     } catch (std::out_of_range& e) {
81948       {
81949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81950       };
81951     } catch (std::exception& e) {
81952       {
81953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81954       };
81955     } catch (...) {
81956       {
81957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81958       };
81959     }
81960   }
81961   jresult = (void *)result;
81962   return jresult;
81963 }
81964
81965
81966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
81967   void * jresult ;
81968   Dali::BaseHandle arg1 ;
81969   Dali::BaseHandle *argp1 ;
81970   Dali::Toolkit::Popup result;
81971
81972   argp1 = (Dali::BaseHandle *)jarg1;
81973   if (!argp1) {
81974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81975     return 0;
81976   }
81977   arg1 = *argp1;
81978   {
81979     try {
81980       result = Dali::Toolkit::Popup::DownCast(arg1);
81981     } catch (std::out_of_range& e) {
81982       {
81983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81984       };
81985     } catch (std::exception& e) {
81986       {
81987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81988       };
81989     } catch (...) {
81990       {
81991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81992       };
81993     }
81994   }
81995   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
81996   return jresult;
81997 }
81998
81999
82000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
82001   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82002   Dali::Actor arg2 ;
82003   Dali::Actor *argp2 ;
82004
82005   arg1 = (Dali::Toolkit::Popup *)jarg1;
82006   argp2 = (Dali::Actor *)jarg2;
82007   if (!argp2) {
82008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82009     return ;
82010   }
82011   arg2 = *argp2;
82012   {
82013     try {
82014       (arg1)->SetTitle(arg2);
82015     } catch (std::out_of_range& e) {
82016       {
82017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82018       };
82019     } catch (std::exception& e) {
82020       {
82021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82022       };
82023     } catch (...) {
82024       {
82025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82026       };
82027     }
82028   }
82029 }
82030
82031
82032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
82033   void * jresult ;
82034   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82035   Dali::Actor result;
82036
82037   arg1 = (Dali::Toolkit::Popup *)jarg1;
82038   {
82039     try {
82040       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
82041     } catch (std::out_of_range& e) {
82042       {
82043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82044       };
82045     } catch (std::exception& e) {
82046       {
82047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82048       };
82049     } catch (...) {
82050       {
82051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82052       };
82053     }
82054   }
82055   jresult = new Dali::Actor((const Dali::Actor &)result);
82056   return jresult;
82057 }
82058
82059
82060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
82061   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82062   Dali::Actor arg2 ;
82063   Dali::Actor *argp2 ;
82064
82065   arg1 = (Dali::Toolkit::Popup *)jarg1;
82066   argp2 = (Dali::Actor *)jarg2;
82067   if (!argp2) {
82068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82069     return ;
82070   }
82071   arg2 = *argp2;
82072   {
82073     try {
82074       (arg1)->SetContent(arg2);
82075     } catch (std::out_of_range& e) {
82076       {
82077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82078       };
82079     } catch (std::exception& e) {
82080       {
82081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82082       };
82083     } catch (...) {
82084       {
82085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82086       };
82087     }
82088   }
82089 }
82090
82091
82092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
82093   void * jresult ;
82094   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82095   Dali::Actor result;
82096
82097   arg1 = (Dali::Toolkit::Popup *)jarg1;
82098   {
82099     try {
82100       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
82101     } catch (std::out_of_range& e) {
82102       {
82103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82104       };
82105     } catch (std::exception& e) {
82106       {
82107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82108       };
82109     } catch (...) {
82110       {
82111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82112       };
82113     }
82114   }
82115   jresult = new Dali::Actor((const Dali::Actor &)result);
82116   return jresult;
82117 }
82118
82119
82120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
82121   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82122   Dali::Actor arg2 ;
82123   Dali::Actor *argp2 ;
82124
82125   arg1 = (Dali::Toolkit::Popup *)jarg1;
82126   argp2 = (Dali::Actor *)jarg2;
82127   if (!argp2) {
82128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82129     return ;
82130   }
82131   arg2 = *argp2;
82132   {
82133     try {
82134       (arg1)->SetFooter(arg2);
82135     } catch (std::out_of_range& e) {
82136       {
82137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82138       };
82139     } catch (std::exception& e) {
82140       {
82141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82142       };
82143     } catch (...) {
82144       {
82145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82146       };
82147     }
82148   }
82149 }
82150
82151
82152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
82153   void * jresult ;
82154   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82155   Dali::Actor result;
82156
82157   arg1 = (Dali::Toolkit::Popup *)jarg1;
82158   {
82159     try {
82160       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
82161     } catch (std::out_of_range& e) {
82162       {
82163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82164       };
82165     } catch (std::exception& e) {
82166       {
82167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82168       };
82169     } catch (...) {
82170       {
82171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82172       };
82173     }
82174   }
82175   jresult = new Dali::Actor((const Dali::Actor &)result);
82176   return jresult;
82177 }
82178
82179
82180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
82181   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82182   Dali::Toolkit::Popup::DisplayState arg2 ;
82183
82184   arg1 = (Dali::Toolkit::Popup *)jarg1;
82185   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
82186   {
82187     try {
82188       (arg1)->SetDisplayState(arg2);
82189     } catch (std::out_of_range& e) {
82190       {
82191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82192       };
82193     } catch (std::exception& e) {
82194       {
82195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82196       };
82197     } catch (...) {
82198       {
82199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82200       };
82201     }
82202   }
82203 }
82204
82205
82206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
82207   int jresult ;
82208   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82209   Dali::Toolkit::Popup::DisplayState result;
82210
82211   arg1 = (Dali::Toolkit::Popup *)jarg1;
82212   {
82213     try {
82214       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
82215     } catch (std::out_of_range& e) {
82216       {
82217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82218       };
82219     } catch (std::exception& e) {
82220       {
82221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82222       };
82223     } catch (...) {
82224       {
82225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82226       };
82227     }
82228   }
82229   jresult = (int)result;
82230   return jresult;
82231 }
82232
82233
82234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
82235   void * jresult ;
82236   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82237   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
82238
82239   arg1 = (Dali::Toolkit::Popup *)jarg1;
82240   {
82241     try {
82242       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
82243     } catch (std::out_of_range& e) {
82244       {
82245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82246       };
82247     } catch (std::exception& e) {
82248       {
82249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82250       };
82251     } catch (...) {
82252       {
82253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82254       };
82255     }
82256   }
82257   jresult = (void *)result;
82258   return jresult;
82259 }
82260
82261
82262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
82263   void * jresult ;
82264   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82265   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82266
82267   arg1 = (Dali::Toolkit::Popup *)jarg1;
82268   {
82269     try {
82270       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
82271     } catch (std::out_of_range& e) {
82272       {
82273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82274       };
82275     } catch (std::exception& e) {
82276       {
82277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82278       };
82279     } catch (...) {
82280       {
82281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82282       };
82283     }
82284   }
82285   jresult = (void *)result;
82286   return jresult;
82287 }
82288
82289
82290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
82291   void * jresult ;
82292   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82293   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82294
82295   arg1 = (Dali::Toolkit::Popup *)jarg1;
82296   {
82297     try {
82298       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
82299     } catch (std::out_of_range& e) {
82300       {
82301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82302       };
82303     } catch (std::exception& e) {
82304       {
82305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82306       };
82307     } catch (...) {
82308       {
82309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82310       };
82311     }
82312   }
82313   jresult = (void *)result;
82314   return jresult;
82315 }
82316
82317
82318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
82319   void * jresult ;
82320   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82321   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82322
82323   arg1 = (Dali::Toolkit::Popup *)jarg1;
82324   {
82325     try {
82326       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
82327     } catch (std::out_of_range& e) {
82328       {
82329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82330       };
82331     } catch (std::exception& e) {
82332       {
82333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82334       };
82335     } catch (...) {
82336       {
82337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82338       };
82339     }
82340   }
82341   jresult = (void *)result;
82342   return jresult;
82343 }
82344
82345
82346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
82347   void * jresult ;
82348   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82349   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82350
82351   arg1 = (Dali::Toolkit::Popup *)jarg1;
82352   {
82353     try {
82354       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
82355     } catch (std::out_of_range& e) {
82356       {
82357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82358       };
82359     } catch (std::exception& e) {
82360       {
82361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82362       };
82363     } catch (...) {
82364       {
82365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82366       };
82367     }
82368   }
82369   jresult = (void *)result;
82370   return jresult;
82371 }
82372
82373
82374 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
82375   int jresult ;
82376   int result;
82377
82378   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
82379   jresult = (int)result;
82380   return jresult;
82381 }
82382
82383
82384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
82385   int jresult ;
82386   int result;
82387
82388   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
82389   jresult = (int)result;
82390   return jresult;
82391 }
82392
82393
82394 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
82395   int jresult ;
82396   int result;
82397
82398   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
82399   jresult = (int)result;
82400   return jresult;
82401 }
82402
82403
82404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
82405   int jresult ;
82406   int result;
82407
82408   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
82409   jresult = (int)result;
82410   return jresult;
82411 }
82412
82413
82414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
82415   int jresult ;
82416   int result;
82417
82418   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
82419   jresult = (int)result;
82420   return jresult;
82421 }
82422
82423
82424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
82425   int jresult ;
82426   int result;
82427
82428   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
82429   jresult = (int)result;
82430   return jresult;
82431 }
82432
82433
82434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
82435   int jresult ;
82436   int result;
82437
82438   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
82439   jresult = (int)result;
82440   return jresult;
82441 }
82442
82443
82444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
82445   int jresult ;
82446   int result;
82447
82448   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
82449   jresult = (int)result;
82450   return jresult;
82451 }
82452
82453
82454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
82455   int jresult ;
82456   int result;
82457
82458   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
82459   jresult = (int)result;
82460   return jresult;
82461 }
82462
82463
82464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
82465   void * jresult ;
82466   Dali::Toolkit::ProgressBar::Property *result = 0 ;
82467
82468   {
82469     try {
82470       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
82471     } catch (std::out_of_range& e) {
82472       {
82473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82474       };
82475     } catch (std::exception& e) {
82476       {
82477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82478       };
82479     } catch (...) {
82480       {
82481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82482       };
82483     }
82484   }
82485   jresult = (void *)result;
82486   return jresult;
82487 }
82488
82489
82490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
82491   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
82492
82493   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
82494   {
82495     try {
82496       delete arg1;
82497     } catch (std::out_of_range& e) {
82498       {
82499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82500       };
82501     } catch (std::exception& e) {
82502       {
82503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82504       };
82505     } catch (...) {
82506       {
82507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82508       };
82509     }
82510   }
82511 }
82512
82513
82514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
82515   void * jresult ;
82516   Dali::Toolkit::ProgressBar result;
82517
82518   {
82519     try {
82520       result = Dali::Toolkit::ProgressBar::New();
82521     } catch (std::out_of_range& e) {
82522       {
82523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82524       };
82525     } catch (std::exception& e) {
82526       {
82527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82528       };
82529     } catch (...) {
82530       {
82531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82532       };
82533     }
82534   }
82535   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
82536   return jresult;
82537 }
82538
82539
82540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
82541   void * jresult ;
82542   Dali::Toolkit::ProgressBar *result = 0 ;
82543
82544   {
82545     try {
82546       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
82547     } catch (std::out_of_range& e) {
82548       {
82549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82550       };
82551     } catch (std::exception& e) {
82552       {
82553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82554       };
82555     } catch (...) {
82556       {
82557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82558       };
82559     }
82560   }
82561   jresult = (void *)result;
82562   return jresult;
82563 }
82564
82565
82566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
82567   void * jresult ;
82568   Dali::Toolkit::ProgressBar *arg1 = 0 ;
82569   Dali::Toolkit::ProgressBar *result = 0 ;
82570
82571   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82572   if (!arg1) {
82573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
82574     return 0;
82575   }
82576   {
82577     try {
82578       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
82579     } catch (std::out_of_range& e) {
82580       {
82581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82582       };
82583     } catch (std::exception& e) {
82584       {
82585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82586       };
82587     } catch (...) {
82588       {
82589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82590       };
82591     }
82592   }
82593   jresult = (void *)result;
82594   return jresult;
82595 }
82596
82597
82598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
82599   void * jresult ;
82600   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
82601   Dali::Toolkit::ProgressBar *arg2 = 0 ;
82602   Dali::Toolkit::ProgressBar *result = 0 ;
82603
82604   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82605   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
82606   if (!arg2) {
82607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
82608     return 0;
82609   }
82610   {
82611     try {
82612       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
82613     } catch (std::out_of_range& e) {
82614       {
82615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82616       };
82617     } catch (std::exception& e) {
82618       {
82619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82620       };
82621     } catch (...) {
82622       {
82623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82624       };
82625     }
82626   }
82627   jresult = (void *)result;
82628   return jresult;
82629 }
82630
82631
82632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
82633   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
82634
82635   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82636   {
82637     try {
82638       delete arg1;
82639     } catch (std::out_of_range& e) {
82640       {
82641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82642       };
82643     } catch (std::exception& e) {
82644       {
82645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82646       };
82647     } catch (...) {
82648       {
82649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82650       };
82651     }
82652   }
82653 }
82654
82655
82656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
82657   void * jresult ;
82658   Dali::BaseHandle arg1 ;
82659   Dali::BaseHandle *argp1 ;
82660   Dali::Toolkit::ProgressBar result;
82661
82662   argp1 = (Dali::BaseHandle *)jarg1;
82663   if (!argp1) {
82664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82665     return 0;
82666   }
82667   arg1 = *argp1;
82668   {
82669     try {
82670       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
82671     } catch (std::out_of_range& e) {
82672       {
82673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82674       };
82675     } catch (std::exception& e) {
82676       {
82677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82678       };
82679     } catch (...) {
82680       {
82681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82682       };
82683     }
82684   }
82685   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
82686   return jresult;
82687 }
82688
82689
82690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
82691   void * jresult ;
82692   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
82693   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
82694
82695   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82696   {
82697     try {
82698       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
82699     } catch (std::out_of_range& e) {
82700       {
82701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82702       };
82703     } catch (std::exception& e) {
82704       {
82705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82706       };
82707     } catch (...) {
82708       {
82709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82710       };
82711     }
82712   }
82713   jresult = (void *)result;
82714   return jresult;
82715 }
82716
82717
82718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
82719   void * jresult ;
82720   Dali::Toolkit::GaussianBlurView *result = 0 ;
82721
82722   {
82723     try {
82724       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
82725     } catch (std::out_of_range& e) {
82726       {
82727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82728       };
82729     } catch (std::exception& e) {
82730       {
82731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82732       };
82733     } catch (...) {
82734       {
82735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82736       };
82737     }
82738   }
82739   jresult = (void *)result;
82740   return jresult;
82741 }
82742
82743
82744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
82745   void * jresult ;
82746   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
82747   Dali::Toolkit::GaussianBlurView *result = 0 ;
82748
82749   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82750   if (!arg1) {
82751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
82752     return 0;
82753   }
82754   {
82755     try {
82756       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
82757     } catch (std::out_of_range& e) {
82758       {
82759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82760       };
82761     } catch (std::exception& e) {
82762       {
82763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82764       };
82765     } catch (...) {
82766       {
82767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82768       };
82769     }
82770   }
82771   jresult = (void *)result;
82772   return jresult;
82773 }
82774
82775
82776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
82777   void * jresult ;
82778   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82779   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
82780   Dali::Toolkit::GaussianBlurView *result = 0 ;
82781
82782   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82783   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
82784   if (!arg2) {
82785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
82786     return 0;
82787   }
82788   {
82789     try {
82790       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
82791     } catch (std::out_of_range& e) {
82792       {
82793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82794       };
82795     } catch (std::exception& e) {
82796       {
82797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82798       };
82799     } catch (...) {
82800       {
82801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82802       };
82803     }
82804   }
82805   jresult = (void *)result;
82806   return jresult;
82807 }
82808
82809
82810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
82811   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82812
82813   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82814   {
82815     try {
82816       delete arg1;
82817     } catch (std::out_of_range& e) {
82818       {
82819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82820       };
82821     } catch (std::exception& e) {
82822       {
82823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82824       };
82825     } catch (...) {
82826       {
82827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82828       };
82829     }
82830   }
82831 }
82832
82833
82834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
82835   void * jresult ;
82836   Dali::BaseHandle arg1 ;
82837   Dali::BaseHandle *argp1 ;
82838   Dali::Toolkit::GaussianBlurView result;
82839
82840   argp1 = (Dali::BaseHandle *)jarg1;
82841   if (!argp1) {
82842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82843     return 0;
82844   }
82845   arg1 = *argp1;
82846   {
82847     try {
82848       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
82849     } catch (std::out_of_range& e) {
82850       {
82851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82852       };
82853     } catch (std::exception& e) {
82854       {
82855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82856       };
82857     } catch (...) {
82858       {
82859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82860       };
82861     }
82862   }
82863   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
82864   return jresult;
82865 }
82866
82867
82868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
82869   void * jresult ;
82870   Dali::Toolkit::GaussianBlurView result;
82871
82872   {
82873     try {
82874       result = Dali::Toolkit::GaussianBlurView::New();
82875     } catch (std::out_of_range& e) {
82876       {
82877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82878       };
82879     } catch (std::exception& e) {
82880       {
82881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82882       };
82883     } catch (...) {
82884       {
82885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82886       };
82887     }
82888   }
82889   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
82890   return jresult;
82891 }
82892
82893
82894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
82895   void * jresult ;
82896   unsigned int arg1 ;
82897   float arg2 ;
82898   Dali::Pixel::Format arg3 ;
82899   float arg4 ;
82900   float arg5 ;
82901   bool arg6 ;
82902   Dali::Toolkit::GaussianBlurView result;
82903
82904   arg1 = (unsigned int)jarg1;
82905   arg2 = (float)jarg2;
82906   arg3 = (Dali::Pixel::Format)jarg3;
82907   arg4 = (float)jarg4;
82908   arg5 = (float)jarg5;
82909   arg6 = jarg6 ? true : false;
82910   {
82911     try {
82912       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
82913     } catch (std::out_of_range& e) {
82914       {
82915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82916       };
82917     } catch (std::exception& e) {
82918       {
82919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82920       };
82921     } catch (...) {
82922       {
82923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82924       };
82925     }
82926   }
82927   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
82928   return jresult;
82929 }
82930
82931
82932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
82933   void * jresult ;
82934   unsigned int arg1 ;
82935   float arg2 ;
82936   Dali::Pixel::Format arg3 ;
82937   float arg4 ;
82938   float arg5 ;
82939   Dali::Toolkit::GaussianBlurView result;
82940
82941   arg1 = (unsigned int)jarg1;
82942   arg2 = (float)jarg2;
82943   arg3 = (Dali::Pixel::Format)jarg3;
82944   arg4 = (float)jarg4;
82945   arg5 = (float)jarg5;
82946   {
82947     try {
82948       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
82949     } catch (std::out_of_range& e) {
82950       {
82951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82952       };
82953     } catch (std::exception& e) {
82954       {
82955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82956       };
82957     } catch (...) {
82958       {
82959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82960       };
82961     }
82962   }
82963   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
82964   return jresult;
82965 }
82966
82967
82968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
82969   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82970   Dali::Actor arg2 ;
82971   Dali::Actor *argp2 ;
82972
82973   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82974   argp2 = (Dali::Actor *)jarg2;
82975   if (!argp2) {
82976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82977     return ;
82978   }
82979   arg2 = *argp2;
82980   {
82981     try {
82982       (arg1)->Add(arg2);
82983     } catch (std::out_of_range& e) {
82984       {
82985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82986       };
82987     } catch (std::exception& e) {
82988       {
82989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82990       };
82991     } catch (...) {
82992       {
82993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82994       };
82995     }
82996   }
82997 }
82998
82999
83000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
83001   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83002   Dali::Actor arg2 ;
83003   Dali::Actor *argp2 ;
83004
83005   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83006   argp2 = (Dali::Actor *)jarg2;
83007   if (!argp2) {
83008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83009     return ;
83010   }
83011   arg2 = *argp2;
83012   {
83013     try {
83014       (arg1)->Remove(arg2);
83015     } catch (std::out_of_range& e) {
83016       {
83017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83018       };
83019     } catch (std::exception& e) {
83020       {
83021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83022       };
83023     } catch (...) {
83024       {
83025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83026       };
83027     }
83028   }
83029 }
83030
83031
83032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
83033   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83034
83035   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83036   {
83037     try {
83038       (arg1)->Activate();
83039     } catch (std::out_of_range& e) {
83040       {
83041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83042       };
83043     } catch (std::exception& e) {
83044       {
83045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83046       };
83047     } catch (...) {
83048       {
83049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83050       };
83051     }
83052   }
83053 }
83054
83055
83056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
83057   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83058
83059   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83060   {
83061     try {
83062       (arg1)->ActivateOnce();
83063     } catch (std::out_of_range& e) {
83064       {
83065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83066       };
83067     } catch (std::exception& e) {
83068       {
83069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83070       };
83071     } catch (...) {
83072       {
83073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83074       };
83075     }
83076   }
83077 }
83078
83079
83080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
83081   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83082
83083   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83084   {
83085     try {
83086       (arg1)->Deactivate();
83087     } catch (std::out_of_range& e) {
83088       {
83089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83090       };
83091     } catch (std::exception& e) {
83092       {
83093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83094       };
83095     } catch (...) {
83096       {
83097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83098       };
83099     }
83100   }
83101 }
83102
83103
83104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
83105   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83106   Dali::Image arg2 ;
83107   Dali::FrameBufferImage arg3 ;
83108   Dali::Image *argp2 ;
83109   Dali::FrameBufferImage *argp3 ;
83110
83111   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83112   argp2 = (Dali::Image *)jarg2;
83113   if (!argp2) {
83114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
83115     return ;
83116   }
83117   arg2 = *argp2;
83118   argp3 = (Dali::FrameBufferImage *)jarg3;
83119   if (!argp3) {
83120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
83121     return ;
83122   }
83123   arg3 = *argp3;
83124   {
83125     try {
83126       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
83127     } catch (std::out_of_range& e) {
83128       {
83129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83130       };
83131     } catch (std::exception& e) {
83132       {
83133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83134       };
83135     } catch (...) {
83136       {
83137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83138       };
83139     }
83140   }
83141 }
83142
83143
83144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
83145   int jresult ;
83146   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83147   Dali::Property::Index result;
83148
83149   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83150   {
83151     try {
83152       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
83153     } catch (std::out_of_range& e) {
83154       {
83155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83156       };
83157     } catch (std::exception& e) {
83158       {
83159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83160       };
83161     } catch (...) {
83162       {
83163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83164       };
83165     }
83166   }
83167   jresult = result;
83168   return jresult;
83169 }
83170
83171
83172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
83173   void * jresult ;
83174   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83175   Dali::FrameBufferImage result;
83176
83177   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83178   {
83179     try {
83180       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
83181     } catch (std::out_of_range& e) {
83182       {
83183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83184       };
83185     } catch (std::exception& e) {
83186       {
83187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83188       };
83189     } catch (...) {
83190       {
83191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83192       };
83193     }
83194   }
83195   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
83196   return jresult;
83197 }
83198
83199
83200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
83201   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83202   Dali::Vector4 *arg2 = 0 ;
83203
83204   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83205   arg2 = (Dali::Vector4 *)jarg2;
83206   if (!arg2) {
83207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
83208     return ;
83209   }
83210   {
83211     try {
83212       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
83213     } catch (std::out_of_range& e) {
83214       {
83215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83216       };
83217     } catch (std::exception& e) {
83218       {
83219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83220       };
83221     } catch (...) {
83222       {
83223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83224       };
83225     }
83226   }
83227 }
83228
83229
83230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
83231   void * jresult ;
83232   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83233   Dali::Vector4 result;
83234
83235   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83236   {
83237     try {
83238       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
83239     } catch (std::out_of_range& e) {
83240       {
83241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83242       };
83243     } catch (std::exception& e) {
83244       {
83245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83246       };
83247     } catch (...) {
83248       {
83249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83250       };
83251     }
83252   }
83253   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
83254   return jresult;
83255 }
83256
83257
83258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
83259   void * jresult ;
83260   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83261   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
83262
83263   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83264   {
83265     try {
83266       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
83267     } catch (std::out_of_range& e) {
83268       {
83269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83270       };
83271     } catch (std::exception& e) {
83272       {
83273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83274       };
83275     } catch (...) {
83276       {
83277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83278       };
83279     }
83280   }
83281   jresult = (void *)result;
83282   return jresult;
83283 }
83284
83285
83286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
83287   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
83288
83289   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83290   {
83291     try {
83292       delete arg1;
83293     } catch (std::out_of_range& e) {
83294       {
83295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83296       };
83297     } catch (std::exception& e) {
83298       {
83299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83300       };
83301     } catch (...) {
83302       {
83303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83304       };
83305     }
83306   }
83307 }
83308
83309
83310 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
83311   unsigned int jresult ;
83312   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
83313   unsigned int result;
83314
83315   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83316   {
83317     try {
83318       result = (unsigned int)(arg1)->GetNumberOfPages();
83319     } catch (std::out_of_range& e) {
83320       {
83321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83322       };
83323     } catch (std::exception& e) {
83324       {
83325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83326       };
83327     } catch (...) {
83328       {
83329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83330       };
83331     }
83332   }
83333   jresult = result;
83334   return jresult;
83335 }
83336
83337
83338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
83339   void * jresult ;
83340   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
83341   unsigned int arg2 ;
83342   Dali::Texture result;
83343
83344   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83345   arg2 = (unsigned int)jarg2;
83346   {
83347     try {
83348       result = (arg1)->NewPage(arg2);
83349     } catch (std::out_of_range& e) {
83350       {
83351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83352       };
83353     } catch (std::exception& e) {
83354       {
83355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83356       };
83357     } catch (...) {
83358       {
83359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83360       };
83361     }
83362   }
83363   jresult = new Dali::Texture((const Dali::Texture &)result);
83364   return jresult;
83365 }
83366
83367
83368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
83369   int jresult ;
83370   int result;
83371
83372   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
83373   jresult = (int)result;
83374   return jresult;
83375 }
83376
83377
83378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
83379   int jresult ;
83380   int result;
83381
83382   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
83383   jresult = (int)result;
83384   return jresult;
83385 }
83386
83387
83388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
83389   int jresult ;
83390   int result;
83391
83392   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
83393   jresult = (int)result;
83394   return jresult;
83395 }
83396
83397
83398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
83399   void * jresult ;
83400   Dali::Toolkit::PageTurnView::Property *result = 0 ;
83401
83402   {
83403     try {
83404       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
83405     } catch (std::out_of_range& e) {
83406       {
83407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83408       };
83409     } catch (std::exception& e) {
83410       {
83411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83412       };
83413     } catch (...) {
83414       {
83415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83416       };
83417     }
83418   }
83419   jresult = (void *)result;
83420   return jresult;
83421 }
83422
83423
83424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
83425   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
83426
83427   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
83428   {
83429     try {
83430       delete arg1;
83431     } catch (std::out_of_range& e) {
83432       {
83433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83434       };
83435     } catch (std::exception& e) {
83436       {
83437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83438       };
83439     } catch (...) {
83440       {
83441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83442       };
83443     }
83444   }
83445 }
83446
83447
83448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
83449   void * jresult ;
83450   Dali::Toolkit::PageTurnView *result = 0 ;
83451
83452   {
83453     try {
83454       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
83455     } catch (std::out_of_range& e) {
83456       {
83457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83458       };
83459     } catch (std::exception& e) {
83460       {
83461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83462       };
83463     } catch (...) {
83464       {
83465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83466       };
83467     }
83468   }
83469   jresult = (void *)result;
83470   return jresult;
83471 }
83472
83473
83474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
83475   void * jresult ;
83476   Dali::Toolkit::PageTurnView *arg1 = 0 ;
83477   Dali::Toolkit::PageTurnView *result = 0 ;
83478
83479   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83480   if (!arg1) {
83481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
83482     return 0;
83483   }
83484   {
83485     try {
83486       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
83487     } catch (std::out_of_range& e) {
83488       {
83489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83490       };
83491     } catch (std::exception& e) {
83492       {
83493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83494       };
83495     } catch (...) {
83496       {
83497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83498       };
83499     }
83500   }
83501   jresult = (void *)result;
83502   return jresult;
83503 }
83504
83505
83506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
83507   void * jresult ;
83508   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83509   Dali::Toolkit::PageTurnView *arg2 = 0 ;
83510   Dali::Toolkit::PageTurnView *result = 0 ;
83511
83512   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83513   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
83514   if (!arg2) {
83515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
83516     return 0;
83517   }
83518   {
83519     try {
83520       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
83521     } catch (std::out_of_range& e) {
83522       {
83523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83524       };
83525     } catch (std::exception& e) {
83526       {
83527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83528       };
83529     } catch (...) {
83530       {
83531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83532       };
83533     }
83534   }
83535   jresult = (void *)result;
83536   return jresult;
83537 }
83538
83539
83540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
83541   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83542
83543   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83544   {
83545     try {
83546       delete arg1;
83547     } catch (std::out_of_range& e) {
83548       {
83549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83550       };
83551     } catch (std::exception& e) {
83552       {
83553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83554       };
83555     } catch (...) {
83556       {
83557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83558       };
83559     }
83560   }
83561 }
83562
83563
83564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
83565   void * jresult ;
83566   Dali::BaseHandle arg1 ;
83567   Dali::BaseHandle *argp1 ;
83568   Dali::Toolkit::PageTurnView result;
83569
83570   argp1 = (Dali::BaseHandle *)jarg1;
83571   if (!argp1) {
83572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83573     return 0;
83574   }
83575   arg1 = *argp1;
83576   {
83577     try {
83578       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
83579     } catch (std::out_of_range& e) {
83580       {
83581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83582       };
83583     } catch (std::exception& e) {
83584       {
83585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83586       };
83587     } catch (...) {
83588       {
83589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83590       };
83591     }
83592   }
83593   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
83594   return jresult;
83595 }
83596
83597
83598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
83599   void * jresult ;
83600   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83601   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
83602
83603   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83604   {
83605     try {
83606       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
83607     } catch (std::out_of_range& e) {
83608       {
83609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83610       };
83611     } catch (std::exception& e) {
83612       {
83613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83614       };
83615     } catch (...) {
83616       {
83617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83618       };
83619     }
83620   }
83621   jresult = (void *)result;
83622   return jresult;
83623 }
83624
83625
83626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
83627   void * jresult ;
83628   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83629   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
83630
83631   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83632   {
83633     try {
83634       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
83635     } catch (std::out_of_range& e) {
83636       {
83637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83638       };
83639     } catch (std::exception& e) {
83640       {
83641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83642       };
83643     } catch (...) {
83644       {
83645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83646       };
83647     }
83648   }
83649   jresult = (void *)result;
83650   return jresult;
83651 }
83652
83653
83654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
83655   void * jresult ;
83656   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83657   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
83658
83659   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83660   {
83661     try {
83662       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
83663     } catch (std::out_of_range& e) {
83664       {
83665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83666       };
83667     } catch (std::exception& e) {
83668       {
83669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83670       };
83671     } catch (...) {
83672       {
83673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83674       };
83675     }
83676   }
83677   jresult = (void *)result;
83678   return jresult;
83679 }
83680
83681
83682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
83683   void * jresult ;
83684   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83685   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
83686
83687   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83688   {
83689     try {
83690       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
83691     } catch (std::out_of_range& e) {
83692       {
83693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83694       };
83695     } catch (std::exception& e) {
83696       {
83697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83698       };
83699     } catch (...) {
83700       {
83701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83702       };
83703     }
83704   }
83705   jresult = (void *)result;
83706   return jresult;
83707 }
83708
83709
83710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
83711   void * jresult ;
83712   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
83713
83714   {
83715     try {
83716       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
83717     } catch (std::out_of_range& e) {
83718       {
83719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83720       };
83721     } catch (std::exception& e) {
83722       {
83723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83724       };
83725     } catch (...) {
83726       {
83727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83728       };
83729     }
83730   }
83731   jresult = (void *)result;
83732   return jresult;
83733 }
83734
83735
83736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
83737   void * jresult ;
83738   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
83739   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
83740
83741   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
83742   if (!arg1) {
83743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
83744     return 0;
83745   }
83746   {
83747     try {
83748       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
83749     } catch (std::out_of_range& e) {
83750       {
83751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83752       };
83753     } catch (std::exception& e) {
83754       {
83755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83756       };
83757     } catch (...) {
83758       {
83759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83760       };
83761     }
83762   }
83763   jresult = (void *)result;
83764   return jresult;
83765 }
83766
83767
83768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
83769   void * jresult ;
83770   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
83771   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
83772   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
83773
83774   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
83775   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
83776   if (!arg2) {
83777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
83778     return 0;
83779   }
83780   {
83781     try {
83782       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
83783     } catch (std::out_of_range& e) {
83784       {
83785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83786       };
83787     } catch (std::exception& e) {
83788       {
83789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83790       };
83791     } catch (...) {
83792       {
83793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83794       };
83795     }
83796   }
83797   jresult = (void *)result;
83798   return jresult;
83799 }
83800
83801
83802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
83803   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
83804
83805   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
83806   {
83807     try {
83808       delete arg1;
83809     } catch (std::out_of_range& e) {
83810       {
83811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83812       };
83813     } catch (std::exception& e) {
83814       {
83815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83816       };
83817     } catch (...) {
83818       {
83819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83820       };
83821     }
83822   }
83823 }
83824
83825
83826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
83827   void * jresult ;
83828   Dali::Toolkit::PageFactory *arg1 = 0 ;
83829   Dali::Vector2 *arg2 = 0 ;
83830   Dali::Toolkit::PageTurnLandscapeView result;
83831
83832   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83833   if (!arg1) {
83834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
83835     return 0;
83836   }
83837   arg2 = (Dali::Vector2 *)jarg2;
83838   if (!arg2) {
83839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
83840     return 0;
83841   }
83842   {
83843     try {
83844       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
83845     } catch (std::out_of_range& e) {
83846       {
83847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83848       };
83849     } catch (std::exception& e) {
83850       {
83851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83852       };
83853     } catch (...) {
83854       {
83855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83856       };
83857     }
83858   }
83859   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
83860   return jresult;
83861 }
83862
83863
83864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
83865   void * jresult ;
83866   Dali::BaseHandle arg1 ;
83867   Dali::BaseHandle *argp1 ;
83868   Dali::Toolkit::PageTurnLandscapeView result;
83869
83870   argp1 = (Dali::BaseHandle *)jarg1;
83871   if (!argp1) {
83872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83873     return 0;
83874   }
83875   arg1 = *argp1;
83876   {
83877     try {
83878       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
83879     } catch (std::out_of_range& e) {
83880       {
83881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83882       };
83883     } catch (std::exception& e) {
83884       {
83885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83886       };
83887     } catch (...) {
83888       {
83889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83890       };
83891     }
83892   }
83893   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
83894   return jresult;
83895 }
83896
83897
83898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
83899   void * jresult ;
83900   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
83901
83902   {
83903     try {
83904       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
83905     } catch (std::out_of_range& e) {
83906       {
83907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83908       };
83909     } catch (std::exception& e) {
83910       {
83911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83912       };
83913     } catch (...) {
83914       {
83915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83916       };
83917     }
83918   }
83919   jresult = (void *)result;
83920   return jresult;
83921 }
83922
83923
83924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
83925   void * jresult ;
83926   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
83927   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
83928
83929   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
83930   if (!arg1) {
83931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
83932     return 0;
83933   }
83934   {
83935     try {
83936       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
83937     } catch (std::out_of_range& e) {
83938       {
83939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83940       };
83941     } catch (std::exception& e) {
83942       {
83943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83944       };
83945     } catch (...) {
83946       {
83947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83948       };
83949     }
83950   }
83951   jresult = (void *)result;
83952   return jresult;
83953 }
83954
83955
83956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
83957   void * jresult ;
83958   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
83959   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
83960   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
83961
83962   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
83963   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
83964   if (!arg2) {
83965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
83966     return 0;
83967   }
83968   {
83969     try {
83970       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
83971     } catch (std::out_of_range& e) {
83972       {
83973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83974       };
83975     } catch (std::exception& e) {
83976       {
83977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83978       };
83979     } catch (...) {
83980       {
83981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83982       };
83983     }
83984   }
83985   jresult = (void *)result;
83986   return jresult;
83987 }
83988
83989
83990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
83991   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
83992
83993   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
83994   {
83995     try {
83996       delete arg1;
83997     } catch (std::out_of_range& e) {
83998       {
83999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84000       };
84001     } catch (std::exception& e) {
84002       {
84003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84004       };
84005     } catch (...) {
84006       {
84007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84008       };
84009     }
84010   }
84011 }
84012
84013
84014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
84015   void * jresult ;
84016   Dali::Toolkit::PageFactory *arg1 = 0 ;
84017   Dali::Vector2 *arg2 = 0 ;
84018   Dali::Toolkit::PageTurnPortraitView result;
84019
84020   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84021   if (!arg1) {
84022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
84023     return 0;
84024   }
84025   arg2 = (Dali::Vector2 *)jarg2;
84026   if (!arg2) {
84027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
84028     return 0;
84029   }
84030   {
84031     try {
84032       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
84033     } catch (std::out_of_range& e) {
84034       {
84035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84036       };
84037     } catch (std::exception& e) {
84038       {
84039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84040       };
84041     } catch (...) {
84042       {
84043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84044       };
84045     }
84046   }
84047   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
84048   return jresult;
84049 }
84050
84051
84052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
84053   void * jresult ;
84054   Dali::BaseHandle arg1 ;
84055   Dali::BaseHandle *argp1 ;
84056   Dali::Toolkit::PageTurnPortraitView result;
84057
84058   argp1 = (Dali::BaseHandle *)jarg1;
84059   if (!argp1) {
84060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84061     return 0;
84062   }
84063   arg1 = *argp1;
84064   {
84065     try {
84066       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
84067     } catch (std::out_of_range& e) {
84068       {
84069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84070       };
84071     } catch (std::exception& e) {
84072       {
84073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84074       };
84075     } catch (...) {
84076       {
84077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84078       };
84079     }
84080   }
84081   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
84082   return jresult;
84083 }
84084
84085
84086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
84087   int jresult ;
84088   int result;
84089
84090   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
84091   jresult = (int)result;
84092   return jresult;
84093 }
84094
84095
84096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
84097   int jresult ;
84098   int result;
84099
84100   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
84101   jresult = (int)result;
84102   return jresult;
84103 }
84104
84105
84106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
84107   int jresult ;
84108   int result;
84109
84110   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
84111   jresult = (int)result;
84112   return jresult;
84113 }
84114
84115
84116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
84117   void * jresult ;
84118   Dali::Toolkit::ToggleButton::Property *result = 0 ;
84119
84120   {
84121     try {
84122       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
84123     } catch (std::out_of_range& e) {
84124       {
84125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84126       };
84127     } catch (std::exception& e) {
84128       {
84129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84130       };
84131     } catch (...) {
84132       {
84133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84134       };
84135     }
84136   }
84137   jresult = (void *)result;
84138   return jresult;
84139 }
84140
84141
84142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
84143   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
84144
84145   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
84146   {
84147     try {
84148       delete arg1;
84149     } catch (std::out_of_range& e) {
84150       {
84151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84152       };
84153     } catch (std::exception& e) {
84154       {
84155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84156       };
84157     } catch (...) {
84158       {
84159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84160       };
84161     }
84162   }
84163 }
84164
84165
84166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
84167   void * jresult ;
84168   Dali::Toolkit::ToggleButton *result = 0 ;
84169
84170   {
84171     try {
84172       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
84173     } catch (std::out_of_range& e) {
84174       {
84175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84176       };
84177     } catch (std::exception& e) {
84178       {
84179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84180       };
84181     } catch (...) {
84182       {
84183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84184       };
84185     }
84186   }
84187   jresult = (void *)result;
84188   return jresult;
84189 }
84190
84191
84192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
84193   void * jresult ;
84194   Dali::Toolkit::ToggleButton *arg1 = 0 ;
84195   Dali::Toolkit::ToggleButton *result = 0 ;
84196
84197   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
84198   if (!arg1) {
84199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
84200     return 0;
84201   }
84202   {
84203     try {
84204       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
84205     } catch (std::out_of_range& e) {
84206       {
84207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84208       };
84209     } catch (std::exception& e) {
84210       {
84211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84212       };
84213     } catch (...) {
84214       {
84215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84216       };
84217     }
84218   }
84219   jresult = (void *)result;
84220   return jresult;
84221 }
84222
84223
84224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
84225   void * jresult ;
84226   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
84227   Dali::Toolkit::ToggleButton *arg2 = 0 ;
84228   Dali::Toolkit::ToggleButton *result = 0 ;
84229
84230   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
84231   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
84232   if (!arg2) {
84233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
84234     return 0;
84235   }
84236   {
84237     try {
84238       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
84239     } catch (std::out_of_range& e) {
84240       {
84241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84242       };
84243     } catch (std::exception& e) {
84244       {
84245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84246       };
84247     } catch (...) {
84248       {
84249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84250       };
84251     }
84252   }
84253   jresult = (void *)result;
84254   return jresult;
84255 }
84256
84257
84258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
84259   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
84260
84261   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
84262   {
84263     try {
84264       delete arg1;
84265     } catch (std::out_of_range& e) {
84266       {
84267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84268       };
84269     } catch (std::exception& e) {
84270       {
84271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84272       };
84273     } catch (...) {
84274       {
84275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84276       };
84277     }
84278   }
84279 }
84280
84281
84282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
84283   void * jresult ;
84284   Dali::Toolkit::ToggleButton result;
84285
84286   {
84287     try {
84288       result = Dali::Toolkit::ToggleButton::New();
84289     } catch (std::out_of_range& e) {
84290       {
84291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84292       };
84293     } catch (std::exception& e) {
84294       {
84295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84296       };
84297     } catch (...) {
84298       {
84299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84300       };
84301     }
84302   }
84303   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
84304   return jresult;
84305 }
84306
84307
84308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
84309   void * jresult ;
84310   Dali::BaseHandle arg1 ;
84311   Dali::BaseHandle *argp1 ;
84312   Dali::Toolkit::ToggleButton result;
84313
84314   argp1 = (Dali::BaseHandle *)jarg1;
84315   if (!argp1) {
84316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84317     return 0;
84318   }
84319   arg1 = *argp1;
84320   {
84321     try {
84322       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
84323     } catch (std::out_of_range& e) {
84324       {
84325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84326       };
84327     } catch (std::exception& e) {
84328       {
84329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84330       };
84331     } catch (...) {
84332       {
84333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84334       };
84335     }
84336   }
84337   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
84338   return jresult;
84339 }
84340
84341
84342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
84343   void * jresult ;
84344   Dali::Toolkit::Visual::Base *result = 0 ;
84345
84346   {
84347     try {
84348       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
84349     } catch (std::out_of_range& e) {
84350       {
84351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84352       };
84353     } catch (std::exception& e) {
84354       {
84355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84356       };
84357     } catch (...) {
84358       {
84359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84360       };
84361     }
84362   }
84363   jresult = (void *)result;
84364   return jresult;
84365 }
84366
84367
84368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
84369   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84370
84371   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84372   {
84373     try {
84374       delete arg1;
84375     } catch (std::out_of_range& e) {
84376       {
84377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84378       };
84379     } catch (std::exception& e) {
84380       {
84381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84382       };
84383     } catch (...) {
84384       {
84385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84386       };
84387     }
84388   }
84389 }
84390
84391
84392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
84393   void * jresult ;
84394   Dali::Toolkit::Visual::Base *arg1 = 0 ;
84395   Dali::Toolkit::Visual::Base *result = 0 ;
84396
84397   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84398   if (!arg1) {
84399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
84400     return 0;
84401   }
84402   {
84403     try {
84404       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
84405     } catch (std::out_of_range& e) {
84406       {
84407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84408       };
84409     } catch (std::exception& e) {
84410       {
84411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84412       };
84413     } catch (...) {
84414       {
84415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84416       };
84417     }
84418   }
84419   jresult = (void *)result;
84420   return jresult;
84421 }
84422
84423
84424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
84425   void * jresult ;
84426   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84427   Dali::Toolkit::Visual::Base *arg2 = 0 ;
84428   Dali::Toolkit::Visual::Base *result = 0 ;
84429
84430   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84431   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
84432   if (!arg2) {
84433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
84434     return 0;
84435   }
84436   {
84437     try {
84438       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
84439     } catch (std::out_of_range& e) {
84440       {
84441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84442       };
84443     } catch (std::exception& e) {
84444       {
84445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84446       };
84447     } catch (...) {
84448       {
84449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84450       };
84451     }
84452   }
84453   jresult = (void *)result;
84454   return jresult;
84455 }
84456
84457
84458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
84459   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84460   std::string *arg2 = 0 ;
84461
84462   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84463   if (!jarg2) {
84464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84465     return ;
84466   }
84467   std::string arg2_str(jarg2);
84468   arg2 = &arg2_str;
84469   {
84470     try {
84471       (arg1)->SetName((std::string const &)*arg2);
84472     } catch (std::out_of_range& e) {
84473       {
84474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84475       };
84476     } catch (std::exception& e) {
84477       {
84478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84479       };
84480     } catch (...) {
84481       {
84482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84483       };
84484     }
84485   }
84486
84487   //argout typemap for const std::string&
84488
84489 }
84490
84491
84492 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
84493   char * jresult ;
84494   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84495   std::string *result = 0 ;
84496
84497   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84498   {
84499     try {
84500       result = (std::string *) &(arg1)->GetName();
84501     } catch (std::out_of_range& e) {
84502       {
84503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84504       };
84505     } catch (std::exception& e) {
84506       {
84507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84508       };
84509     } catch (...) {
84510       {
84511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84512       };
84513     }
84514   }
84515   jresult = SWIG_csharp_string_callback(result->c_str());
84516   return jresult;
84517 }
84518
84519
84520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
84521   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84522   Dali::Property::Map *arg2 = 0 ;
84523   Dali::Size arg3 ;
84524   Dali::Size *argp3 ;
84525
84526   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84527   arg2 = (Dali::Property::Map *)jarg2;
84528   if (!arg2) {
84529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
84530     return ;
84531   }
84532   argp3 = (Dali::Size *)jarg3;
84533   if (!argp3) {
84534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
84535     return ;
84536   }
84537   arg3 = *argp3;
84538   {
84539     try {
84540       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
84541     } catch (std::out_of_range& e) {
84542       {
84543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84544       };
84545     } catch (std::exception& e) {
84546       {
84547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84548       };
84549     } catch (...) {
84550       {
84551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84552       };
84553     }
84554   }
84555 }
84556
84557
84558 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
84559   float jresult ;
84560   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84561   float arg2 ;
84562   float result;
84563
84564   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84565   arg2 = (float)jarg2;
84566   {
84567     try {
84568       result = (float)(arg1)->GetHeightForWidth(arg2);
84569     } catch (std::out_of_range& e) {
84570       {
84571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84572       };
84573     } catch (std::exception& e) {
84574       {
84575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84576       };
84577     } catch (...) {
84578       {
84579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84580       };
84581     }
84582   }
84583   jresult = result;
84584   return jresult;
84585 }
84586
84587
84588 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
84589   float jresult ;
84590   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84591   float arg2 ;
84592   float result;
84593
84594   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84595   arg2 = (float)jarg2;
84596   {
84597     try {
84598       result = (float)(arg1)->GetWidthForHeight(arg2);
84599     } catch (std::out_of_range& e) {
84600       {
84601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84602       };
84603     } catch (std::exception& e) {
84604       {
84605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84606       };
84607     } catch (...) {
84608       {
84609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84610       };
84611     }
84612   }
84613   jresult = result;
84614   return jresult;
84615 }
84616
84617
84618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
84619   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84620   Dali::Vector2 *arg2 = 0 ;
84621
84622   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84623   arg2 = (Dali::Vector2 *)jarg2;
84624   if (!arg2) {
84625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
84626     return ;
84627   }
84628   {
84629     try {
84630       (arg1)->GetNaturalSize(*arg2);
84631     } catch (std::out_of_range& e) {
84632       {
84633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84634       };
84635     } catch (std::exception& e) {
84636       {
84637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84638       };
84639     } catch (...) {
84640       {
84641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84642       };
84643     }
84644   }
84645 }
84646
84647
84648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, float jarg2) {
84649   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84650   float arg2 ;
84651
84652   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84653   arg2 = (float)jarg2;
84654   {
84655     try {
84656       (arg1)->SetDepthIndex(arg2);
84657     } catch (std::out_of_range& e) {
84658       {
84659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84660       };
84661     } catch (std::exception& e) {
84662       {
84663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84664       };
84665     } catch (...) {
84666       {
84667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84668       };
84669     }
84670   }
84671 }
84672
84673
84674 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
84675   float jresult ;
84676   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84677   float result;
84678
84679   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84680   {
84681     try {
84682       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
84683     } catch (std::out_of_range& e) {
84684       {
84685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84686       };
84687     } catch (std::exception& e) {
84688       {
84689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84690       };
84691     } catch (...) {
84692       {
84693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84694       };
84695     }
84696   }
84697   jresult = result;
84698   return jresult;
84699 }
84700
84701
84702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
84703   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84704   Dali::Property::Map *arg2 = 0 ;
84705
84706   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84707   arg2 = (Dali::Property::Map *)jarg2;
84708   if (!arg2) {
84709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
84710     return ;
84711   }
84712   {
84713     try {
84714       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
84715     } catch (std::out_of_range& e) {
84716       {
84717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84718       };
84719     } catch (std::exception& e) {
84720       {
84721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84722       };
84723     } catch (...) {
84724       {
84725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84726       };
84727     }
84728   }
84729 }
84730
84731
84732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
84733   void * jresult ;
84734   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
84735   Dali::Toolkit::Visual::Base *result = 0 ;
84736
84737   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
84738   {
84739     try {
84740       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
84741     } catch (std::out_of_range& e) {
84742       {
84743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84744       };
84745     } catch (std::exception& e) {
84746       {
84747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84748       };
84749     } catch (...) {
84750       {
84751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84752       };
84753     }
84754   }
84755   jresult = (void *)result;
84756   return jresult;
84757 }
84758
84759
84760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
84761   void * jresult ;
84762   Dali::Toolkit::VisualFactory result;
84763
84764   {
84765     try {
84766       result = Dali::Toolkit::VisualFactory::Get();
84767     } catch (std::out_of_range& e) {
84768       {
84769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84770       };
84771     } catch (std::exception& e) {
84772       {
84773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84774       };
84775     } catch (...) {
84776       {
84777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84778       };
84779     }
84780   }
84781   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
84782   return jresult;
84783 }
84784
84785
84786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
84787   void * jresult ;
84788   Dali::Toolkit::VisualFactory *result = 0 ;
84789
84790   {
84791     try {
84792       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
84793     } catch (std::out_of_range& e) {
84794       {
84795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84796       };
84797     } catch (std::exception& e) {
84798       {
84799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84800       };
84801     } catch (...) {
84802       {
84803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84804       };
84805     }
84806   }
84807   jresult = (void *)result;
84808   return jresult;
84809 }
84810
84811
84812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
84813   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84814
84815   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84816   {
84817     try {
84818       delete arg1;
84819     } catch (std::out_of_range& e) {
84820       {
84821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84822       };
84823     } catch (std::exception& e) {
84824       {
84825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84826       };
84827     } catch (...) {
84828       {
84829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84830       };
84831     }
84832   }
84833 }
84834
84835
84836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
84837   void * jresult ;
84838   Dali::Toolkit::VisualFactory *arg1 = 0 ;
84839   Dali::Toolkit::VisualFactory *result = 0 ;
84840
84841   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84842   if (!arg1) {
84843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
84844     return 0;
84845   }
84846   {
84847     try {
84848       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
84849     } catch (std::out_of_range& e) {
84850       {
84851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84852       };
84853     } catch (std::exception& e) {
84854       {
84855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84856       };
84857     } catch (...) {
84858       {
84859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84860       };
84861     }
84862   }
84863   jresult = (void *)result;
84864   return jresult;
84865 }
84866
84867
84868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
84869   void * jresult ;
84870   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84871   Dali::Toolkit::VisualFactory *arg2 = 0 ;
84872   Dali::Toolkit::VisualFactory *result = 0 ;
84873
84874   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84875   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
84876   if (!arg2) {
84877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
84878     return 0;
84879   }
84880   {
84881     try {
84882       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
84883     } catch (std::out_of_range& e) {
84884       {
84885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84886       };
84887     } catch (std::exception& e) {
84888       {
84889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84890       };
84891     } catch (...) {
84892       {
84893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84894       };
84895     }
84896   }
84897   jresult = (void *)result;
84898   return jresult;
84899 }
84900
84901
84902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
84903   void * jresult ;
84904   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84905   Dali::Property::Map *arg2 = 0 ;
84906   Dali::Toolkit::Visual::Base result;
84907
84908   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84909   arg2 = (Dali::Property::Map *)jarg2;
84910   if (!arg2) {
84911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
84912     return 0;
84913   }
84914   {
84915     try {
84916       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
84917     } catch (std::out_of_range& e) {
84918       {
84919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84920       };
84921     } catch (std::exception& e) {
84922       {
84923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84924       };
84925     } catch (...) {
84926       {
84927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84928       };
84929     }
84930   }
84931   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
84932   return jresult;
84933 }
84934
84935
84936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
84937   void * jresult ;
84938   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84939   Dali::Image *arg2 = 0 ;
84940   Dali::Toolkit::Visual::Base result;
84941
84942   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84943   arg2 = (Dali::Image *)jarg2;
84944   if (!arg2) {
84945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
84946     return 0;
84947   }
84948   {
84949     try {
84950       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
84951     } catch (std::out_of_range& e) {
84952       {
84953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84954       };
84955     } catch (std::exception& e) {
84956       {
84957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84958       };
84959     } catch (...) {
84960       {
84961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84962       };
84963     }
84964   }
84965   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
84966   return jresult;
84967 }
84968
84969
84970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
84971   void * jresult ;
84972   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84973   std::string *arg2 = 0 ;
84974   Dali::ImageDimensions arg3 ;
84975   Dali::ImageDimensions *argp3 ;
84976   Dali::Toolkit::Visual::Base result;
84977
84978   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84979   if (!jarg2) {
84980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84981     return 0;
84982   }
84983   std::string arg2_str(jarg2);
84984   arg2 = &arg2_str;
84985   argp3 = (Dali::ImageDimensions *)jarg3;
84986   if (!argp3) {
84987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
84988     return 0;
84989   }
84990   arg3 = *argp3;
84991   {
84992     try {
84993       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
84994     } catch (std::out_of_range& e) {
84995       {
84996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84997       };
84998     } catch (std::exception& e) {
84999       {
85000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85001       };
85002     } catch (...) {
85003       {
85004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85005       };
85006     }
85007   }
85008   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
85009
85010   //argout typemap for const std::string&
85011
85012   return jresult;
85013 }
85014
85015
85016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
85017   void * jresult ;
85018   Dali::Toolkit::AsyncImageLoader *result = 0 ;
85019
85020   {
85021     try {
85022       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
85023     } catch (std::out_of_range& e) {
85024       {
85025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85026       };
85027     } catch (std::exception& e) {
85028       {
85029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85030       };
85031     } catch (...) {
85032       {
85033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85034       };
85035     }
85036   }
85037   jresult = (void *)result;
85038   return jresult;
85039 }
85040
85041
85042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
85043   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85044
85045   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85046   {
85047     try {
85048       delete arg1;
85049     } catch (std::out_of_range& e) {
85050       {
85051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85052       };
85053     } catch (std::exception& e) {
85054       {
85055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85056       };
85057     } catch (...) {
85058       {
85059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85060       };
85061     }
85062   }
85063 }
85064
85065
85066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
85067   void * jresult ;
85068   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
85069   Dali::Toolkit::AsyncImageLoader *result = 0 ;
85070
85071   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85072   if (!arg1) {
85073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
85074     return 0;
85075   }
85076   {
85077     try {
85078       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
85079     } catch (std::out_of_range& e) {
85080       {
85081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85082       };
85083     } catch (std::exception& e) {
85084       {
85085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85086       };
85087     } catch (...) {
85088       {
85089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85090       };
85091     }
85092   }
85093   jresult = (void *)result;
85094   return jresult;
85095 }
85096
85097
85098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
85099   void * jresult ;
85100   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85101   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
85102   Dali::Toolkit::AsyncImageLoader *result = 0 ;
85103
85104   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85105   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
85106   if (!arg2) {
85107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
85108     return 0;
85109   }
85110   {
85111     try {
85112       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
85113     } catch (std::out_of_range& e) {
85114       {
85115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85116       };
85117     } catch (std::exception& e) {
85118       {
85119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85120       };
85121     } catch (...) {
85122       {
85123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85124       };
85125     }
85126   }
85127   jresult = (void *)result;
85128   return jresult;
85129 }
85130
85131
85132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
85133   void * jresult ;
85134   Dali::Toolkit::AsyncImageLoader result;
85135
85136   {
85137     try {
85138       result = Dali::Toolkit::AsyncImageLoader::New();
85139     } catch (std::out_of_range& e) {
85140       {
85141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85142       };
85143     } catch (std::exception& e) {
85144       {
85145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85146       };
85147     } catch (...) {
85148       {
85149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85150       };
85151     }
85152   }
85153   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
85154   return jresult;
85155 }
85156
85157
85158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
85159   void * jresult ;
85160   Dali::BaseHandle arg1 ;
85161   Dali::BaseHandle *argp1 ;
85162   Dali::Toolkit::AsyncImageLoader result;
85163
85164   argp1 = (Dali::BaseHandle *)jarg1;
85165   if (!argp1) {
85166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85167     return 0;
85168   }
85169   arg1 = *argp1;
85170   {
85171     try {
85172       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
85173     } catch (std::out_of_range& e) {
85174       {
85175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85176       };
85177     } catch (std::exception& e) {
85178       {
85179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85180       };
85181     } catch (...) {
85182       {
85183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85184       };
85185     }
85186   }
85187   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
85188   return jresult;
85189 }
85190
85191
85192 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
85193   unsigned int jresult ;
85194   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85195   std::string *arg2 = 0 ;
85196   uint32_t result;
85197
85198   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85199   if (!jarg2) {
85200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85201     return 0;
85202   }
85203   std::string arg2_str(jarg2);
85204   arg2 = &arg2_str;
85205   {
85206     try {
85207       result = (arg1)->Load((std::string const &)*arg2);
85208     } catch (std::out_of_range& e) {
85209       {
85210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85211       };
85212     } catch (std::exception& e) {
85213       {
85214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85215       };
85216     } catch (...) {
85217       {
85218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85219       };
85220     }
85221   }
85222   jresult = result;
85223
85224   //argout typemap for const std::string&
85225
85226   return jresult;
85227 }
85228
85229
85230 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
85231   unsigned int jresult ;
85232   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85233   std::string *arg2 = 0 ;
85234   Dali::ImageDimensions arg3 ;
85235   Dali::ImageDimensions *argp3 ;
85236   uint32_t result;
85237
85238   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85239   if (!jarg2) {
85240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85241     return 0;
85242   }
85243   std::string arg2_str(jarg2);
85244   arg2 = &arg2_str;
85245   argp3 = (Dali::ImageDimensions *)jarg3;
85246   if (!argp3) {
85247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85248     return 0;
85249   }
85250   arg3 = *argp3;
85251   {
85252     try {
85253       result = (arg1)->Load((std::string const &)*arg2,arg3);
85254     } catch (std::out_of_range& e) {
85255       {
85256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85257       };
85258     } catch (std::exception& e) {
85259       {
85260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85261       };
85262     } catch (...) {
85263       {
85264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85265       };
85266     }
85267   }
85268   jresult = result;
85269
85270   //argout typemap for const std::string&
85271
85272   return jresult;
85273 }
85274
85275
85276 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
85277   unsigned int jresult ;
85278   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85279   std::string *arg2 = 0 ;
85280   Dali::ImageDimensions arg3 ;
85281   Dali::FittingMode::Type arg4 ;
85282   Dali::SamplingMode::Type arg5 ;
85283   bool arg6 ;
85284   Dali::ImageDimensions *argp3 ;
85285   uint32_t result;
85286
85287   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85288   if (!jarg2) {
85289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85290     return 0;
85291   }
85292   std::string arg2_str(jarg2);
85293   arg2 = &arg2_str;
85294   argp3 = (Dali::ImageDimensions *)jarg3;
85295   if (!argp3) {
85296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85297     return 0;
85298   }
85299   arg3 = *argp3;
85300   arg4 = (Dali::FittingMode::Type)jarg4;
85301   arg5 = (Dali::SamplingMode::Type)jarg5;
85302   arg6 = jarg6 ? true : false;
85303   {
85304     try {
85305       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
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 = result;
85321
85322   //argout typemap for const std::string&
85323
85324   return jresult;
85325 }
85326
85327
85328 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
85329   unsigned int jresult ;
85330   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85331   uint32_t arg2 ;
85332   bool result;
85333
85334   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85335   arg2 = (uint32_t)jarg2;
85336   {
85337     try {
85338       result = (bool)(arg1)->Cancel(arg2);
85339     } catch (std::out_of_range& e) {
85340       {
85341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85342       };
85343     } catch (std::exception& e) {
85344       {
85345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85346       };
85347     } catch (...) {
85348       {
85349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85350       };
85351     }
85352   }
85353   jresult = result;
85354   return jresult;
85355 }
85356
85357
85358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
85359   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85360
85361   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85362   {
85363     try {
85364       (arg1)->CancelAll();
85365     } catch (std::out_of_range& e) {
85366       {
85367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85368       };
85369     } catch (std::exception& e) {
85370       {
85371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85372       };
85373     } catch (...) {
85374       {
85375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85376       };
85377     }
85378   }
85379 }
85380
85381
85382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
85383   void * jresult ;
85384   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85385   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
85386
85387   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85388   {
85389     try {
85390       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
85391     } catch (std::out_of_range& e) {
85392       {
85393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85394       };
85395     } catch (std::exception& e) {
85396       {
85397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85398       };
85399     } catch (...) {
85400       {
85401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85402       };
85403     }
85404   }
85405   jresult = (void *)result;
85406   return jresult;
85407 }
85408
85409
85410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
85411   void * jresult ;
85412   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
85413   Dali::Toolkit::AsyncImageLoader *result = 0 ;
85414
85415   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
85416   {
85417     try {
85418       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
85419     } catch (std::out_of_range& e) {
85420       {
85421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85422       };
85423     } catch (std::exception& e) {
85424       {
85425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85426       };
85427     } catch (...) {
85428       {
85429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85430       };
85431     }
85432   }
85433   jresult = (void *)result;
85434   return jresult;
85435 }
85436
85437
85438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
85439   void * jresult ;
85440   std::string *arg1 = 0 ;
85441   Dali::PixelData result;
85442
85443   if (!jarg1) {
85444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85445     return 0;
85446   }
85447   std::string arg1_str(jarg1);
85448   arg1 = &arg1_str;
85449   {
85450     try {
85451       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
85452     } catch (std::out_of_range& e) {
85453       {
85454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85455       };
85456     } catch (std::exception& e) {
85457       {
85458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85459       };
85460     } catch (...) {
85461       {
85462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85463       };
85464     }
85465   }
85466   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85467
85468   //argout typemap for const std::string&
85469
85470   return jresult;
85471 }
85472
85473
85474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
85475   void * jresult ;
85476   std::string *arg1 = 0 ;
85477   Dali::ImageDimensions arg2 ;
85478   Dali::ImageDimensions *argp2 ;
85479   Dali::PixelData result;
85480
85481   if (!jarg1) {
85482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85483     return 0;
85484   }
85485   std::string arg1_str(jarg1);
85486   arg1 = &arg1_str;
85487   argp2 = (Dali::ImageDimensions *)jarg2;
85488   if (!argp2) {
85489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85490     return 0;
85491   }
85492   arg2 = *argp2;
85493   {
85494     try {
85495       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
85496     } catch (std::out_of_range& e) {
85497       {
85498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85499       };
85500     } catch (std::exception& e) {
85501       {
85502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85503       };
85504     } catch (...) {
85505       {
85506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85507       };
85508     }
85509   }
85510   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85511
85512   //argout typemap for const std::string&
85513
85514   return jresult;
85515 }
85516
85517
85518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
85519   void * jresult ;
85520   std::string *arg1 = 0 ;
85521   Dali::ImageDimensions arg2 ;
85522   Dali::FittingMode::Type arg3 ;
85523   Dali::SamplingMode::Type arg4 ;
85524   bool arg5 ;
85525   Dali::ImageDimensions *argp2 ;
85526   Dali::PixelData result;
85527
85528   if (!jarg1) {
85529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85530     return 0;
85531   }
85532   std::string arg1_str(jarg1);
85533   arg1 = &arg1_str;
85534   argp2 = (Dali::ImageDimensions *)jarg2;
85535   if (!argp2) {
85536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85537     return 0;
85538   }
85539   arg2 = *argp2;
85540   arg3 = (Dali::FittingMode::Type)jarg3;
85541   arg4 = (Dali::SamplingMode::Type)jarg4;
85542   arg5 = jarg5 ? true : false;
85543   {
85544     try {
85545       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
85546     } catch (std::out_of_range& e) {
85547       {
85548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85549       };
85550     } catch (std::exception& e) {
85551       {
85552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85553       };
85554     } catch (...) {
85555       {
85556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85557       };
85558     }
85559   }
85560   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85561
85562   //argout typemap for const std::string&
85563
85564   return jresult;
85565 }
85566
85567
85568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
85569   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
85570
85571   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
85572   {
85573     try {
85574       delete arg1;
85575     } catch (std::out_of_range& e) {
85576       {
85577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85578       };
85579     } catch (std::exception& e) {
85580       {
85581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85582       };
85583     } catch (...) {
85584       {
85585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85586       };
85587     }
85588   }
85589 }
85590
85591
85592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
85593   void * jresult ;
85594   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
85595   Dali::Actor arg2 ;
85596   Dali::Actor arg3 ;
85597   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
85598   Dali::Actor *argp2 ;
85599   Dali::Actor *argp3 ;
85600   Dali::Actor result;
85601
85602   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
85603   argp2 = (Dali::Actor *)jarg2;
85604   if (!argp2) {
85605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85606     return 0;
85607   }
85608   arg2 = *argp2;
85609   argp3 = (Dali::Actor *)jarg3;
85610   if (!argp3) {
85611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85612     return 0;
85613   }
85614   arg3 = *argp3;
85615   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
85616   {
85617     try {
85618       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
85619     } catch (std::out_of_range& e) {
85620       {
85621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85622       };
85623     } catch (std::exception& e) {
85624       {
85625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85626       };
85627     } catch (...) {
85628       {
85629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85630       };
85631     }
85632   }
85633   jresult = new Dali::Actor((const Dali::Actor &)result);
85634   return jresult;
85635 }
85636
85637
85638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
85639   void * jresult ;
85640   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
85641
85642   {
85643     try {
85644       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
85645     } catch (std::out_of_range& e) {
85646       {
85647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85648       };
85649     } catch (std::exception& e) {
85650       {
85651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85652       };
85653     } catch (...) {
85654       {
85655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85656       };
85657     }
85658   }
85659   jresult = (void *)result;
85660   return jresult;
85661 }
85662
85663
85664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
85665   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
85666   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
85667   if (director) {
85668     director->swig_connect_director(callback0);
85669   }
85670 }
85671
85672
85673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
85674   KeyboardFocusManager arg1 ;
85675   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
85676   KeyboardFocusManager *argp1 ;
85677
85678   argp1 = (KeyboardFocusManager *)jarg1;
85679   if (!argp1) {
85680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
85681     return ;
85682   }
85683   arg1 = *argp1;
85684   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
85685   if (!arg2) {
85686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
85687     return ;
85688   }
85689   {
85690     try {
85691       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
85692     } catch (std::out_of_range& e) {
85693       {
85694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85695       };
85696     } catch (std::exception& e) {
85697       {
85698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85699       };
85700     } catch (...) {
85701       {
85702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85703       };
85704     }
85705   }
85706 }
85707
85708
85709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
85710   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85711
85712   arg1 = (std::vector< unsigned int > *)jarg1;
85713   {
85714     try {
85715       (arg1)->clear();
85716     } catch (std::out_of_range& e) {
85717       {
85718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85719       };
85720     } catch (std::exception& e) {
85721       {
85722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85723       };
85724     } catch (...) {
85725       {
85726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85727       };
85728     }
85729   }
85730 }
85731
85732
85733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
85734   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85735   unsigned int *arg2 = 0 ;
85736   unsigned int temp2 ;
85737
85738   arg1 = (std::vector< unsigned int > *)jarg1;
85739   temp2 = (unsigned int)jarg2;
85740   arg2 = &temp2;
85741   {
85742     try {
85743       (arg1)->push_back((unsigned int const &)*arg2);
85744     } catch (std::out_of_range& e) {
85745       {
85746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85747       };
85748     } catch (std::exception& e) {
85749       {
85750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85751       };
85752     } catch (...) {
85753       {
85754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85755       };
85756     }
85757   }
85758 }
85759
85760
85761 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
85762   unsigned long jresult ;
85763   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85764   std::vector< unsigned int >::size_type result;
85765
85766   arg1 = (std::vector< unsigned int > *)jarg1;
85767   {
85768     try {
85769       result = ((std::vector< unsigned int > const *)arg1)->size();
85770     } catch (std::out_of_range& e) {
85771       {
85772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85773       };
85774     } catch (std::exception& e) {
85775       {
85776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85777       };
85778     } catch (...) {
85779       {
85780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85781       };
85782     }
85783   }
85784   jresult = (unsigned long)result;
85785   return jresult;
85786 }
85787
85788
85789 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
85790   unsigned long jresult ;
85791   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85792   std::vector< unsigned int >::size_type result;
85793
85794   arg1 = (std::vector< unsigned int > *)jarg1;
85795   {
85796     try {
85797       result = ((std::vector< unsigned int > const *)arg1)->capacity();
85798     } catch (std::out_of_range& e) {
85799       {
85800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85801       };
85802     } catch (std::exception& e) {
85803       {
85804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85805       };
85806     } catch (...) {
85807       {
85808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85809       };
85810     }
85811   }
85812   jresult = (unsigned long)result;
85813   return jresult;
85814 }
85815
85816
85817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
85818   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85819   std::vector< unsigned int >::size_type arg2 ;
85820
85821   arg1 = (std::vector< unsigned int > *)jarg1;
85822   arg2 = (std::vector< unsigned int >::size_type)jarg2;
85823   {
85824     try {
85825       (arg1)->reserve(arg2);
85826     } catch (std::out_of_range& e) {
85827       {
85828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85829       };
85830     } catch (std::exception& e) {
85831       {
85832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85833       };
85834     } catch (...) {
85835       {
85836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85837       };
85838     }
85839   }
85840 }
85841
85842
85843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
85844   void * jresult ;
85845   std::vector< unsigned int > *result = 0 ;
85846
85847   {
85848     try {
85849       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
85850     } catch (std::out_of_range& e) {
85851       {
85852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85853       };
85854     } catch (std::exception& e) {
85855       {
85856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85857       };
85858     } catch (...) {
85859       {
85860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85861       };
85862     }
85863   }
85864   jresult = (void *)result;
85865   return jresult;
85866 }
85867
85868
85869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
85870   void * jresult ;
85871   std::vector< unsigned int > *arg1 = 0 ;
85872   std::vector< unsigned int > *result = 0 ;
85873
85874   arg1 = (std::vector< unsigned int > *)jarg1;
85875   if (!arg1) {
85876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
85877     return 0;
85878   }
85879   {
85880     try {
85881       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
85882     } catch (std::out_of_range& e) {
85883       {
85884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85885       };
85886     } catch (std::exception& e) {
85887       {
85888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85889       };
85890     } catch (...) {
85891       {
85892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85893       };
85894     }
85895   }
85896   jresult = (void *)result;
85897   return jresult;
85898 }
85899
85900
85901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
85902   void * jresult ;
85903   int arg1 ;
85904   std::vector< unsigned int > *result = 0 ;
85905
85906   arg1 = (int)jarg1;
85907   {
85908     try {
85909       try {
85910         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
85911       }
85912       catch(std::out_of_range &_e) {
85913         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85914         return 0;
85915       }
85916
85917     } catch (std::out_of_range& e) {
85918       {
85919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85920       };
85921     } catch (std::exception& e) {
85922       {
85923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85924       };
85925     } catch (...) {
85926       {
85927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85928       };
85929     }
85930   }
85931   jresult = (void *)result;
85932   return jresult;
85933 }
85934
85935
85936 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
85937   unsigned int jresult ;
85938   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85939   int arg2 ;
85940   unsigned int result;
85941
85942   arg1 = (std::vector< unsigned int > *)jarg1;
85943   arg2 = (int)jarg2;
85944   {
85945     try {
85946       try {
85947         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
85948       }
85949       catch(std::out_of_range &_e) {
85950         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85951         return 0;
85952       }
85953
85954     } catch (std::out_of_range& e) {
85955       {
85956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85957       };
85958     } catch (std::exception& e) {
85959       {
85960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85961       };
85962     } catch (...) {
85963       {
85964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85965       };
85966     }
85967   }
85968   jresult = result;
85969   return jresult;
85970 }
85971
85972
85973 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
85974   unsigned int jresult ;
85975   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85976   int arg2 ;
85977   unsigned int *result = 0 ;
85978
85979   arg1 = (std::vector< unsigned int > *)jarg1;
85980   arg2 = (int)jarg2;
85981   {
85982     try {
85983       try {
85984         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
85985       }
85986       catch(std::out_of_range &_e) {
85987         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85988         return 0;
85989       }
85990
85991     } catch (std::out_of_range& e) {
85992       {
85993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85994       };
85995     } catch (std::exception& e) {
85996       {
85997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85998       };
85999     } catch (...) {
86000       {
86001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86002       };
86003     }
86004   }
86005   jresult = *result;
86006   return jresult;
86007 }
86008
86009
86010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
86011   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86012   int arg2 ;
86013   unsigned int *arg3 = 0 ;
86014   unsigned int temp3 ;
86015
86016   arg1 = (std::vector< unsigned int > *)jarg1;
86017   arg2 = (int)jarg2;
86018   temp3 = (unsigned int)jarg3;
86019   arg3 = &temp3;
86020   {
86021     try {
86022       try {
86023         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
86024       }
86025       catch(std::out_of_range &_e) {
86026         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86027         return ;
86028       }
86029
86030     } catch (std::out_of_range& e) {
86031       {
86032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86033       };
86034     } catch (std::exception& e) {
86035       {
86036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86037       };
86038     } catch (...) {
86039       {
86040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86041       };
86042     }
86043   }
86044 }
86045
86046
86047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
86048   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86049   std::vector< unsigned int > *arg2 = 0 ;
86050
86051   arg1 = (std::vector< unsigned int > *)jarg1;
86052   arg2 = (std::vector< unsigned int > *)jarg2;
86053   if (!arg2) {
86054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86055     return ;
86056   }
86057   {
86058     try {
86059       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
86060     } catch (std::out_of_range& e) {
86061       {
86062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86063       };
86064     } catch (std::exception& e) {
86065       {
86066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86067       };
86068     } catch (...) {
86069       {
86070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86071       };
86072     }
86073   }
86074 }
86075
86076
86077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
86078   void * jresult ;
86079   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86080   int arg2 ;
86081   int arg3 ;
86082   std::vector< unsigned int > *result = 0 ;
86083
86084   arg1 = (std::vector< unsigned int > *)jarg1;
86085   arg2 = (int)jarg2;
86086   arg3 = (int)jarg3;
86087   {
86088     try {
86089       try {
86090         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
86091       }
86092       catch(std::out_of_range &_e) {
86093         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86094         return 0;
86095       }
86096       catch(std::invalid_argument &_e) {
86097         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86098         return 0;
86099       }
86100
86101     } catch (std::out_of_range& e) {
86102       {
86103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86104       };
86105     } catch (std::exception& e) {
86106       {
86107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86108       };
86109     } catch (...) {
86110       {
86111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86112       };
86113     }
86114   }
86115   jresult = (void *)result;
86116   return jresult;
86117 }
86118
86119
86120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
86121   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86122   int arg2 ;
86123   unsigned int *arg3 = 0 ;
86124   unsigned int temp3 ;
86125
86126   arg1 = (std::vector< unsigned int > *)jarg1;
86127   arg2 = (int)jarg2;
86128   temp3 = (unsigned int)jarg3;
86129   arg3 = &temp3;
86130   {
86131     try {
86132       try {
86133         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
86134       }
86135       catch(std::out_of_range &_e) {
86136         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86137         return ;
86138       }
86139
86140     } catch (std::out_of_range& e) {
86141       {
86142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86143       };
86144     } catch (std::exception& e) {
86145       {
86146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86147       };
86148     } catch (...) {
86149       {
86150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86151       };
86152     }
86153   }
86154 }
86155
86156
86157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
86158   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86159   int arg2 ;
86160   std::vector< unsigned int > *arg3 = 0 ;
86161
86162   arg1 = (std::vector< unsigned int > *)jarg1;
86163   arg2 = (int)jarg2;
86164   arg3 = (std::vector< unsigned int > *)jarg3;
86165   if (!arg3) {
86166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86167     return ;
86168   }
86169   {
86170     try {
86171       try {
86172         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
86173       }
86174       catch(std::out_of_range &_e) {
86175         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86176         return ;
86177       }
86178
86179     } catch (std::out_of_range& e) {
86180       {
86181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86182       };
86183     } catch (std::exception& e) {
86184       {
86185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86186       };
86187     } catch (...) {
86188       {
86189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86190       };
86191     }
86192   }
86193 }
86194
86195
86196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
86197   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86198   int arg2 ;
86199
86200   arg1 = (std::vector< unsigned int > *)jarg1;
86201   arg2 = (int)jarg2;
86202   {
86203     try {
86204       try {
86205         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
86206       }
86207       catch(std::out_of_range &_e) {
86208         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86209         return ;
86210       }
86211
86212     } catch (std::out_of_range& e) {
86213       {
86214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86215       };
86216     } catch (std::exception& e) {
86217       {
86218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86219       };
86220     } catch (...) {
86221       {
86222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86223       };
86224     }
86225   }
86226 }
86227
86228
86229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
86230   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86231   int arg2 ;
86232   int arg3 ;
86233
86234   arg1 = (std::vector< unsigned int > *)jarg1;
86235   arg2 = (int)jarg2;
86236   arg3 = (int)jarg3;
86237   {
86238     try {
86239       try {
86240         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
86241       }
86242       catch(std::out_of_range &_e) {
86243         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86244         return ;
86245       }
86246       catch(std::invalid_argument &_e) {
86247         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86248         return ;
86249       }
86250
86251     } catch (std::out_of_range& e) {
86252       {
86253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86254       };
86255     } catch (std::exception& e) {
86256       {
86257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86258       };
86259     } catch (...) {
86260       {
86261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86262       };
86263     }
86264   }
86265 }
86266
86267
86268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
86269   void * jresult ;
86270   unsigned int *arg1 = 0 ;
86271   int arg2 ;
86272   unsigned int temp1 ;
86273   std::vector< unsigned int > *result = 0 ;
86274
86275   temp1 = (unsigned int)jarg1;
86276   arg1 = &temp1;
86277   arg2 = (int)jarg2;
86278   {
86279     try {
86280       try {
86281         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
86282       }
86283       catch(std::out_of_range &_e) {
86284         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86285         return 0;
86286       }
86287
86288     } catch (std::out_of_range& e) {
86289       {
86290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86291       };
86292     } catch (std::exception& e) {
86293       {
86294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86295       };
86296     } catch (...) {
86297       {
86298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86299       };
86300     }
86301   }
86302   jresult = (void *)result;
86303   return jresult;
86304 }
86305
86306
86307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
86308   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86309
86310   arg1 = (std::vector< unsigned int > *)jarg1;
86311   {
86312     try {
86313       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
86314     } catch (std::out_of_range& e) {
86315       {
86316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86317       };
86318     } catch (std::exception& e) {
86319       {
86320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86321       };
86322     } catch (...) {
86323       {
86324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86325       };
86326     }
86327   }
86328 }
86329
86330
86331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
86332   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86333   int arg2 ;
86334   int arg3 ;
86335
86336   arg1 = (std::vector< unsigned int > *)jarg1;
86337   arg2 = (int)jarg2;
86338   arg3 = (int)jarg3;
86339   {
86340     try {
86341       try {
86342         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
86343       }
86344       catch(std::out_of_range &_e) {
86345         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86346         return ;
86347       }
86348       catch(std::invalid_argument &_e) {
86349         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86350         return ;
86351       }
86352
86353     } catch (std::out_of_range& e) {
86354       {
86355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86356       };
86357     } catch (std::exception& e) {
86358       {
86359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86360       };
86361     } catch (...) {
86362       {
86363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86364       };
86365     }
86366   }
86367 }
86368
86369
86370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
86371   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86372   int arg2 ;
86373   std::vector< unsigned int > *arg3 = 0 ;
86374
86375   arg1 = (std::vector< unsigned int > *)jarg1;
86376   arg2 = (int)jarg2;
86377   arg3 = (std::vector< unsigned int > *)jarg3;
86378   if (!arg3) {
86379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86380     return ;
86381   }
86382   {
86383     try {
86384       try {
86385         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
86386       }
86387       catch(std::out_of_range &_e) {
86388         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86389         return ;
86390       }
86391
86392     } catch (std::out_of_range& e) {
86393       {
86394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86395       };
86396     } catch (std::exception& e) {
86397       {
86398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86399       };
86400     } catch (...) {
86401       {
86402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86403       };
86404     }
86405   }
86406 }
86407
86408
86409 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
86410   unsigned int jresult ;
86411   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86412   unsigned int *arg2 = 0 ;
86413   unsigned int temp2 ;
86414   bool result;
86415
86416   arg1 = (std::vector< unsigned int > *)jarg1;
86417   temp2 = (unsigned int)jarg2;
86418   arg2 = &temp2;
86419   {
86420     try {
86421       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
86422     } catch (std::out_of_range& e) {
86423       {
86424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86425       };
86426     } catch (std::exception& e) {
86427       {
86428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86429       };
86430     } catch (...) {
86431       {
86432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86433       };
86434     }
86435   }
86436   jresult = result;
86437   return jresult;
86438 }
86439
86440
86441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
86442   int jresult ;
86443   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86444   unsigned int *arg2 = 0 ;
86445   unsigned int temp2 ;
86446   int result;
86447
86448   arg1 = (std::vector< unsigned int > *)jarg1;
86449   temp2 = (unsigned int)jarg2;
86450   arg2 = &temp2;
86451   {
86452     try {
86453       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
86454     } catch (std::out_of_range& e) {
86455       {
86456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86457       };
86458     } catch (std::exception& e) {
86459       {
86460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86461       };
86462     } catch (...) {
86463       {
86464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86465       };
86466     }
86467   }
86468   jresult = result;
86469   return jresult;
86470 }
86471
86472
86473 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
86474   int jresult ;
86475   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86476   unsigned int *arg2 = 0 ;
86477   unsigned int temp2 ;
86478   int result;
86479
86480   arg1 = (std::vector< unsigned int > *)jarg1;
86481   temp2 = (unsigned int)jarg2;
86482   arg2 = &temp2;
86483   {
86484     try {
86485       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
86486     } catch (std::out_of_range& e) {
86487       {
86488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86489       };
86490     } catch (std::exception& e) {
86491       {
86492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86493       };
86494     } catch (...) {
86495       {
86496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86497       };
86498     }
86499   }
86500   jresult = result;
86501   return jresult;
86502 }
86503
86504
86505 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
86506   unsigned int jresult ;
86507   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86508   unsigned int *arg2 = 0 ;
86509   unsigned int temp2 ;
86510   bool result;
86511
86512   arg1 = (std::vector< unsigned int > *)jarg1;
86513   temp2 = (unsigned int)jarg2;
86514   arg2 = &temp2;
86515   {
86516     try {
86517       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
86518     } catch (std::out_of_range& e) {
86519       {
86520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86521       };
86522     } catch (std::exception& e) {
86523       {
86524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86525       };
86526     } catch (...) {
86527       {
86528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86529       };
86530     }
86531   }
86532   jresult = result;
86533   return jresult;
86534 }
86535
86536
86537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
86538   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86539
86540   arg1 = (std::vector< unsigned int > *)jarg1;
86541   {
86542     try {
86543       delete arg1;
86544     } catch (std::out_of_range& e) {
86545       {
86546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86547       };
86548     } catch (std::exception& e) {
86549       {
86550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86551       };
86552     } catch (...) {
86553       {
86554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86555       };
86556     }
86557   }
86558 }
86559
86560
86561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
86562   void * jresult ;
86563   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86564
86565   {
86566     try {
86567       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
86568     } catch (std::out_of_range& e) {
86569       {
86570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86571       };
86572     } catch (std::exception& e) {
86573       {
86574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86575       };
86576     } catch (...) {
86577       {
86578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86579       };
86580     }
86581   }
86582   jresult = (void *)result;
86583   return jresult;
86584 }
86585
86586
86587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
86588   void * jresult ;
86589   unsigned int arg1 ;
86590   Dali::Actor arg2 ;
86591   Dali::Actor *argp2 ;
86592   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86593
86594   arg1 = (unsigned int)jarg1;
86595   argp2 = (Dali::Actor *)jarg2;
86596   if (!argp2) {
86597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86598     return 0;
86599   }
86600   arg2 = *argp2;
86601   {
86602     try {
86603       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
86604     } catch (std::out_of_range& e) {
86605       {
86606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86607       };
86608     } catch (std::exception& e) {
86609       {
86610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86611       };
86612     } catch (...) {
86613       {
86614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86615       };
86616     }
86617   }
86618   jresult = (void *)result;
86619   return jresult;
86620 }
86621
86622
86623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
86624   void * jresult ;
86625   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
86626   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86627
86628   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86629   if (!arg1) {
86630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
86631     return 0;
86632   }
86633   {
86634     try {
86635       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
86636     } catch (std::out_of_range& e) {
86637       {
86638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86639       };
86640     } catch (std::exception& e) {
86641       {
86642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86643       };
86644     } catch (...) {
86645       {
86646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86647       };
86648     }
86649   }
86650   jresult = (void *)result;
86651   return jresult;
86652 }
86653
86654
86655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
86656   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86657   unsigned int arg2 ;
86658
86659   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86660   arg2 = (unsigned int)jarg2;
86661   if (arg1) (arg1)->first = arg2;
86662 }
86663
86664
86665 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
86666   unsigned int jresult ;
86667   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86668   unsigned int result;
86669
86670   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86671   result = (unsigned int) ((arg1)->first);
86672   jresult = result;
86673   return jresult;
86674 }
86675
86676
86677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
86678   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86679   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
86680
86681   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86682   arg2 = (Dali::Actor *)jarg2;
86683   if (arg1) (arg1)->second = *arg2;
86684 }
86685
86686
86687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
86688   void * jresult ;
86689   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86690   Dali::Actor *result = 0 ;
86691
86692   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86693   result = (Dali::Actor *)& ((arg1)->second);
86694   jresult = (void *)result;
86695   return jresult;
86696 }
86697
86698
86699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
86700   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86701
86702   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86703   {
86704     try {
86705       delete arg1;
86706     } catch (std::out_of_range& e) {
86707       {
86708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86709       };
86710     } catch (std::exception& e) {
86711       {
86712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86713       };
86714     } catch (...) {
86715       {
86716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86717       };
86718     }
86719   }
86720 }
86721
86722
86723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
86724   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86725
86726   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86727   {
86728     try {
86729       (arg1)->clear();
86730     } catch (std::out_of_range& e) {
86731       {
86732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86733       };
86734     } catch (std::exception& e) {
86735       {
86736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86737       };
86738     } catch (...) {
86739       {
86740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86741       };
86742     }
86743   }
86744 }
86745
86746
86747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
86748   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86749   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
86750
86751   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86752   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
86753   if (!arg2) {
86754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
86755     return ;
86756   }
86757   {
86758     try {
86759       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
86760     } catch (std::out_of_range& e) {
86761       {
86762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86763       };
86764     } catch (std::exception& e) {
86765       {
86766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86767       };
86768     } catch (...) {
86769       {
86770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86771       };
86772     }
86773   }
86774 }
86775
86776
86777 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
86778   unsigned long jresult ;
86779   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86780   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
86781
86782   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86783   {
86784     try {
86785       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
86786     } catch (std::out_of_range& e) {
86787       {
86788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86789       };
86790     } catch (std::exception& e) {
86791       {
86792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86793       };
86794     } catch (...) {
86795       {
86796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86797       };
86798     }
86799   }
86800   jresult = (unsigned long)result;
86801   return jresult;
86802 }
86803
86804
86805 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
86806   unsigned long jresult ;
86807   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86808   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
86809
86810   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86811   {
86812     try {
86813       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
86814     } catch (std::out_of_range& e) {
86815       {
86816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86817       };
86818     } catch (std::exception& e) {
86819       {
86820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86821       };
86822     } catch (...) {
86823       {
86824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86825       };
86826     }
86827   }
86828   jresult = (unsigned long)result;
86829   return jresult;
86830 }
86831
86832
86833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
86834   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86835   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
86836
86837   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86838   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
86839   {
86840     try {
86841       (arg1)->reserve(arg2);
86842     } catch (std::out_of_range& e) {
86843       {
86844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86845       };
86846     } catch (std::exception& e) {
86847       {
86848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86849       };
86850     } catch (...) {
86851       {
86852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86853       };
86854     }
86855   }
86856 }
86857
86858
86859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
86860   void * jresult ;
86861   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
86862
86863   {
86864     try {
86865       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
86866     } catch (std::out_of_range& e) {
86867       {
86868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86869       };
86870     } catch (std::exception& e) {
86871       {
86872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86873       };
86874     } catch (...) {
86875       {
86876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86877       };
86878     }
86879   }
86880   jresult = (void *)result;
86881   return jresult;
86882 }
86883
86884
86885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
86886   void * jresult ;
86887   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
86888   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
86889
86890   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86891   if (!arg1) {
86892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
86893     return 0;
86894   }
86895   {
86896     try {
86897       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);
86898     } catch (std::out_of_range& e) {
86899       {
86900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86901       };
86902     } catch (std::exception& e) {
86903       {
86904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86905       };
86906     } catch (...) {
86907       {
86908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86909       };
86910     }
86911   }
86912   jresult = (void *)result;
86913   return jresult;
86914 }
86915
86916
86917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
86918   void * jresult ;
86919   int arg1 ;
86920   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
86921
86922   arg1 = (int)jarg1;
86923   {
86924     try {
86925       try {
86926         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);
86927       }
86928       catch(std::out_of_range &_e) {
86929         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86930         return 0;
86931       }
86932
86933     } catch (std::out_of_range& e) {
86934       {
86935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86936       };
86937     } catch (std::exception& e) {
86938       {
86939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86940       };
86941     } catch (...) {
86942       {
86943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86944       };
86945     }
86946   }
86947   jresult = (void *)result;
86948   return jresult;
86949 }
86950
86951
86952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
86953   void * jresult ;
86954   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86955   int arg2 ;
86956   std::pair< unsigned int,Dali::Actor > result;
86957
86958   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86959   arg2 = (int)jarg2;
86960   {
86961     try {
86962       try {
86963         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
86964       }
86965       catch(std::out_of_range &_e) {
86966         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86967         return 0;
86968       }
86969
86970     } catch (std::out_of_range& e) {
86971       {
86972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86973       };
86974     } catch (std::exception& e) {
86975       {
86976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86977       };
86978     } catch (...) {
86979       {
86980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86981       };
86982     }
86983   }
86984   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
86985   return jresult;
86986 }
86987
86988
86989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
86990   void * jresult ;
86991   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86992   int arg2 ;
86993   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86994
86995   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86996   arg2 = (int)jarg2;
86997   {
86998     try {
86999       try {
87000         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
87001       }
87002       catch(std::out_of_range &_e) {
87003         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87004         return 0;
87005       }
87006
87007     } catch (std::out_of_range& e) {
87008       {
87009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87010       };
87011     } catch (std::exception& e) {
87012       {
87013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87014       };
87015     } catch (...) {
87016       {
87017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87018       };
87019     }
87020   }
87021   jresult = (void *)result;
87022   return jresult;
87023 }
87024
87025
87026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
87027   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87028   int arg2 ;
87029   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
87030
87031   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87032   arg2 = (int)jarg2;
87033   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
87034   if (!arg3) {
87035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87036     return ;
87037   }
87038   {
87039     try {
87040       try {
87041         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);
87042       }
87043       catch(std::out_of_range &_e) {
87044         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87045         return ;
87046       }
87047
87048     } catch (std::out_of_range& e) {
87049       {
87050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87051       };
87052     } catch (std::exception& e) {
87053       {
87054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87055       };
87056     } catch (...) {
87057       {
87058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87059       };
87060     }
87061   }
87062 }
87063
87064
87065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
87066   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87067   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
87068
87069   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87070   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
87071   if (!arg2) {
87072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87073     return ;
87074   }
87075   {
87076     try {
87077       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);
87078     } catch (std::out_of_range& e) {
87079       {
87080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87081       };
87082     } catch (std::exception& e) {
87083       {
87084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87085       };
87086     } catch (...) {
87087       {
87088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87089       };
87090     }
87091   }
87092 }
87093
87094
87095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87096   void * jresult ;
87097   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87098   int arg2 ;
87099   int arg3 ;
87100   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87101
87102   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87103   arg2 = (int)jarg2;
87104   arg3 = (int)jarg3;
87105   {
87106     try {
87107       try {
87108         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);
87109       }
87110       catch(std::out_of_range &_e) {
87111         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87112         return 0;
87113       }
87114       catch(std::invalid_argument &_e) {
87115         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87116         return 0;
87117       }
87118
87119     } catch (std::out_of_range& e) {
87120       {
87121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87122       };
87123     } catch (std::exception& e) {
87124       {
87125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87126       };
87127     } catch (...) {
87128       {
87129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87130       };
87131     }
87132   }
87133   jresult = (void *)result;
87134   return jresult;
87135 }
87136
87137
87138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
87139   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87140   int arg2 ;
87141   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
87142
87143   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87144   arg2 = (int)jarg2;
87145   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
87146   if (!arg3) {
87147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87148     return ;
87149   }
87150   {
87151     try {
87152       try {
87153         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);
87154       }
87155       catch(std::out_of_range &_e) {
87156         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87157         return ;
87158       }
87159
87160     } catch (std::out_of_range& e) {
87161       {
87162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87163       };
87164     } catch (std::exception& e) {
87165       {
87166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87167       };
87168     } catch (...) {
87169       {
87170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87171       };
87172     }
87173   }
87174 }
87175
87176
87177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87178   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87179   int arg2 ;
87180   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
87181
87182   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87183   arg2 = (int)jarg2;
87184   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
87185   if (!arg3) {
87186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87187     return ;
87188   }
87189   {
87190     try {
87191       try {
87192         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);
87193       }
87194       catch(std::out_of_range &_e) {
87195         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87196         return ;
87197       }
87198
87199     } catch (std::out_of_range& e) {
87200       {
87201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87202       };
87203     } catch (std::exception& e) {
87204       {
87205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87206       };
87207     } catch (...) {
87208       {
87209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87210       };
87211     }
87212   }
87213 }
87214
87215
87216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
87217   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87218   int arg2 ;
87219
87220   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87221   arg2 = (int)jarg2;
87222   {
87223     try {
87224       try {
87225         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
87226       }
87227       catch(std::out_of_range &_e) {
87228         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87229         return ;
87230       }
87231
87232     } catch (std::out_of_range& e) {
87233       {
87234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87235       };
87236     } catch (std::exception& e) {
87237       {
87238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87239       };
87240     } catch (...) {
87241       {
87242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87243       };
87244     }
87245   }
87246 }
87247
87248
87249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
87250   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87251   int arg2 ;
87252   int arg3 ;
87253
87254   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87255   arg2 = (int)jarg2;
87256   arg3 = (int)jarg3;
87257   {
87258     try {
87259       try {
87260         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
87261       }
87262       catch(std::out_of_range &_e) {
87263         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87264         return ;
87265       }
87266       catch(std::invalid_argument &_e) {
87267         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87268         return ;
87269       }
87270
87271     } catch (std::out_of_range& e) {
87272       {
87273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87274       };
87275     } catch (std::exception& e) {
87276       {
87277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87278       };
87279     } catch (...) {
87280       {
87281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87282       };
87283     }
87284   }
87285 }
87286
87287
87288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
87289   void * jresult ;
87290   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
87291   int arg2 ;
87292   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87293
87294   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87295   if (!arg1) {
87296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87297     return 0;
87298   }
87299   arg2 = (int)jarg2;
87300   {
87301     try {
87302       try {
87303         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);
87304       }
87305       catch(std::out_of_range &_e) {
87306         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87307         return 0;
87308       }
87309
87310     } catch (std::out_of_range& e) {
87311       {
87312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87313       };
87314     } catch (std::exception& e) {
87315       {
87316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87317       };
87318     } catch (...) {
87319       {
87320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87321       };
87322     }
87323   }
87324   jresult = (void *)result;
87325   return jresult;
87326 }
87327
87328
87329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
87330   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87331
87332   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87333   {
87334     try {
87335       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
87336     } catch (std::out_of_range& e) {
87337       {
87338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87339       };
87340     } catch (std::exception& e) {
87341       {
87342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87343       };
87344     } catch (...) {
87345       {
87346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87347       };
87348     }
87349   }
87350 }
87351
87352
87353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
87354   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87355   int arg2 ;
87356   int arg3 ;
87357
87358   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87359   arg2 = (int)jarg2;
87360   arg3 = (int)jarg3;
87361   {
87362     try {
87363       try {
87364         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
87365       }
87366       catch(std::out_of_range &_e) {
87367         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87368         return ;
87369       }
87370       catch(std::invalid_argument &_e) {
87371         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87372         return ;
87373       }
87374
87375     } catch (std::out_of_range& e) {
87376       {
87377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87378       };
87379     } catch (std::exception& e) {
87380       {
87381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87382       };
87383     } catch (...) {
87384       {
87385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87386       };
87387     }
87388   }
87389 }
87390
87391
87392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
87393   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87394   int arg2 ;
87395   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
87396
87397   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87398   arg2 = (int)jarg2;
87399   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
87400   if (!arg3) {
87401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87402     return ;
87403   }
87404   {
87405     try {
87406       try {
87407         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);
87408       }
87409       catch(std::out_of_range &_e) {
87410         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87411         return ;
87412       }
87413
87414     } catch (std::out_of_range& e) {
87415       {
87416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87417       };
87418     } catch (std::exception& e) {
87419       {
87420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87421       };
87422     } catch (...) {
87423       {
87424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87425       };
87426     }
87427   }
87428 }
87429
87430
87431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
87432   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87433
87434   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87435   {
87436     try {
87437       delete arg1;
87438     } catch (std::out_of_range& e) {
87439       {
87440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87441       };
87442     } catch (std::exception& e) {
87443       {
87444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87445       };
87446     } catch (...) {
87447       {
87448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87449       };
87450     }
87451   }
87452 }
87453
87454
87455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
87456   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87457
87458   arg1 = (std::vector< Dali::Actor > *)jarg1;
87459   {
87460     try {
87461       (arg1)->clear();
87462     } catch (std::out_of_range& e) {
87463       {
87464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87465       };
87466     } catch (std::exception& e) {
87467       {
87468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87469       };
87470     } catch (...) {
87471       {
87472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87473       };
87474     }
87475   }
87476 }
87477
87478
87479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
87480   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87481   Dali::Actor *arg2 = 0 ;
87482
87483   arg1 = (std::vector< Dali::Actor > *)jarg1;
87484   arg2 = (Dali::Actor *)jarg2;
87485   if (!arg2) {
87486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
87487     return ;
87488   }
87489   {
87490     try {
87491       (arg1)->push_back((Dali::Actor const &)*arg2);
87492     } catch (std::out_of_range& e) {
87493       {
87494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87495       };
87496     } catch (std::exception& e) {
87497       {
87498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87499       };
87500     } catch (...) {
87501       {
87502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87503       };
87504     }
87505   }
87506 }
87507
87508
87509 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
87510   unsigned long jresult ;
87511   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87512   std::vector< Dali::Actor >::size_type result;
87513
87514   arg1 = (std::vector< Dali::Actor > *)jarg1;
87515   {
87516     try {
87517       result = ((std::vector< Dali::Actor > const *)arg1)->size();
87518     } catch (std::out_of_range& e) {
87519       {
87520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87521       };
87522     } catch (std::exception& e) {
87523       {
87524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87525       };
87526     } catch (...) {
87527       {
87528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87529       };
87530     }
87531   }
87532   jresult = (unsigned long)result;
87533   return jresult;
87534 }
87535
87536
87537 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
87538   unsigned long jresult ;
87539   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87540   std::vector< Dali::Actor >::size_type result;
87541
87542   arg1 = (std::vector< Dali::Actor > *)jarg1;
87543   {
87544     try {
87545       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
87546     } catch (std::out_of_range& e) {
87547       {
87548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87549       };
87550     } catch (std::exception& e) {
87551       {
87552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87553       };
87554     } catch (...) {
87555       {
87556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87557       };
87558     }
87559   }
87560   jresult = (unsigned long)result;
87561   return jresult;
87562 }
87563
87564
87565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
87566   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87567   std::vector< Dali::Actor >::size_type arg2 ;
87568
87569   arg1 = (std::vector< Dali::Actor > *)jarg1;
87570   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
87571   {
87572     try {
87573       (arg1)->reserve(arg2);
87574     } catch (std::out_of_range& e) {
87575       {
87576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87577       };
87578     } catch (std::exception& e) {
87579       {
87580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87581       };
87582     } catch (...) {
87583       {
87584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87585       };
87586     }
87587   }
87588 }
87589
87590
87591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
87592   void * jresult ;
87593   std::vector< Dali::Actor > *result = 0 ;
87594
87595   {
87596     try {
87597       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
87598     } catch (std::out_of_range& e) {
87599       {
87600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87601       };
87602     } catch (std::exception& e) {
87603       {
87604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87605       };
87606     } catch (...) {
87607       {
87608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87609       };
87610     }
87611   }
87612   jresult = (void *)result;
87613   return jresult;
87614 }
87615
87616
87617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
87618   void * jresult ;
87619   std::vector< Dali::Actor > *arg1 = 0 ;
87620   std::vector< Dali::Actor > *result = 0 ;
87621
87622   arg1 = (std::vector< Dali::Actor > *)jarg1;
87623   if (!arg1) {
87624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
87625     return 0;
87626   }
87627   {
87628     try {
87629       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
87630     } catch (std::out_of_range& e) {
87631       {
87632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87633       };
87634     } catch (std::exception& e) {
87635       {
87636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87637       };
87638     } catch (...) {
87639       {
87640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87641       };
87642     }
87643   }
87644   jresult = (void *)result;
87645   return jresult;
87646 }
87647
87648
87649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
87650   void * jresult ;
87651   int arg1 ;
87652   std::vector< Dali::Actor > *result = 0 ;
87653
87654   arg1 = (int)jarg1;
87655   {
87656     try {
87657       try {
87658         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
87659       }
87660       catch(std::out_of_range &_e) {
87661         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87662         return 0;
87663       }
87664
87665     } catch (std::out_of_range& e) {
87666       {
87667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87668       };
87669     } catch (std::exception& e) {
87670       {
87671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87672       };
87673     } catch (...) {
87674       {
87675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87676       };
87677     }
87678   }
87679   jresult = (void *)result;
87680   return jresult;
87681 }
87682
87683
87684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
87685   void * jresult ;
87686   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87687   int arg2 ;
87688   Dali::Actor result;
87689
87690   arg1 = (std::vector< Dali::Actor > *)jarg1;
87691   arg2 = (int)jarg2;
87692   {
87693     try {
87694       try {
87695         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
87696       }
87697       catch(std::out_of_range &_e) {
87698         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87699         return 0;
87700       }
87701
87702     } catch (std::out_of_range& e) {
87703       {
87704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87705       };
87706     } catch (std::exception& e) {
87707       {
87708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87709       };
87710     } catch (...) {
87711       {
87712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87713       };
87714     }
87715   }
87716   jresult = new Dali::Actor((const Dali::Actor &)result);
87717   return jresult;
87718 }
87719
87720
87721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
87722   void * jresult ;
87723   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87724   int arg2 ;
87725   Dali::Actor *result = 0 ;
87726
87727   arg1 = (std::vector< Dali::Actor > *)jarg1;
87728   arg2 = (int)jarg2;
87729   {
87730     try {
87731       try {
87732         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
87733       }
87734       catch(std::out_of_range &_e) {
87735         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87736         return 0;
87737       }
87738
87739     } catch (std::out_of_range& e) {
87740       {
87741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87742       };
87743     } catch (std::exception& e) {
87744       {
87745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87746       };
87747     } catch (...) {
87748       {
87749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87750       };
87751     }
87752   }
87753   jresult = (void *)result;
87754   return jresult;
87755 }
87756
87757
87758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
87759   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87760   int arg2 ;
87761   Dali::Actor *arg3 = 0 ;
87762
87763   arg1 = (std::vector< Dali::Actor > *)jarg1;
87764   arg2 = (int)jarg2;
87765   arg3 = (Dali::Actor *)jarg3;
87766   if (!arg3) {
87767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
87768     return ;
87769   }
87770   {
87771     try {
87772       try {
87773         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
87774       }
87775       catch(std::out_of_range &_e) {
87776         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87777         return ;
87778       }
87779
87780     } catch (std::out_of_range& e) {
87781       {
87782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87783       };
87784     } catch (std::exception& e) {
87785       {
87786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87787       };
87788     } catch (...) {
87789       {
87790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87791       };
87792     }
87793   }
87794 }
87795
87796
87797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
87798   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87799   std::vector< Dali::Actor > *arg2 = 0 ;
87800
87801   arg1 = (std::vector< Dali::Actor > *)jarg1;
87802   arg2 = (std::vector< Dali::Actor > *)jarg2;
87803   if (!arg2) {
87804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
87805     return ;
87806   }
87807   {
87808     try {
87809       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
87810     } catch (std::out_of_range& e) {
87811       {
87812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87813       };
87814     } catch (std::exception& e) {
87815       {
87816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87817       };
87818     } catch (...) {
87819       {
87820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87821       };
87822     }
87823   }
87824 }
87825
87826
87827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87828   void * jresult ;
87829   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87830   int arg2 ;
87831   int arg3 ;
87832   std::vector< Dali::Actor > *result = 0 ;
87833
87834   arg1 = (std::vector< Dali::Actor > *)jarg1;
87835   arg2 = (int)jarg2;
87836   arg3 = (int)jarg3;
87837   {
87838     try {
87839       try {
87840         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
87841       }
87842       catch(std::out_of_range &_e) {
87843         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87844         return 0;
87845       }
87846       catch(std::invalid_argument &_e) {
87847         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87848         return 0;
87849       }
87850
87851     } catch (std::out_of_range& e) {
87852       {
87853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87854       };
87855     } catch (std::exception& e) {
87856       {
87857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87858       };
87859     } catch (...) {
87860       {
87861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87862       };
87863     }
87864   }
87865   jresult = (void *)result;
87866   return jresult;
87867 }
87868
87869
87870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
87871   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87872   int arg2 ;
87873   Dali::Actor *arg3 = 0 ;
87874
87875   arg1 = (std::vector< Dali::Actor > *)jarg1;
87876   arg2 = (int)jarg2;
87877   arg3 = (Dali::Actor *)jarg3;
87878   if (!arg3) {
87879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
87880     return ;
87881   }
87882   {
87883     try {
87884       try {
87885         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
87886       }
87887       catch(std::out_of_range &_e) {
87888         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87889         return ;
87890       }
87891
87892     } catch (std::out_of_range& e) {
87893       {
87894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87895       };
87896     } catch (std::exception& e) {
87897       {
87898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87899       };
87900     } catch (...) {
87901       {
87902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87903       };
87904     }
87905   }
87906 }
87907
87908
87909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87910   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87911   int arg2 ;
87912   std::vector< Dali::Actor > *arg3 = 0 ;
87913
87914   arg1 = (std::vector< Dali::Actor > *)jarg1;
87915   arg2 = (int)jarg2;
87916   arg3 = (std::vector< Dali::Actor > *)jarg3;
87917   if (!arg3) {
87918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
87919     return ;
87920   }
87921   {
87922     try {
87923       try {
87924         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
87925       }
87926       catch(std::out_of_range &_e) {
87927         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87928         return ;
87929       }
87930
87931     } catch (std::out_of_range& e) {
87932       {
87933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87934       };
87935     } catch (std::exception& e) {
87936       {
87937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87938       };
87939     } catch (...) {
87940       {
87941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87942       };
87943     }
87944   }
87945 }
87946
87947
87948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
87949   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87950   int arg2 ;
87951
87952   arg1 = (std::vector< Dali::Actor > *)jarg1;
87953   arg2 = (int)jarg2;
87954   {
87955     try {
87956       try {
87957         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
87958       }
87959       catch(std::out_of_range &_e) {
87960         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87961         return ;
87962       }
87963
87964     } catch (std::out_of_range& e) {
87965       {
87966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87967       };
87968     } catch (std::exception& e) {
87969       {
87970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87971       };
87972     } catch (...) {
87973       {
87974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87975       };
87976     }
87977   }
87978 }
87979
87980
87981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
87982   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87983   int arg2 ;
87984   int arg3 ;
87985
87986   arg1 = (std::vector< Dali::Actor > *)jarg1;
87987   arg2 = (int)jarg2;
87988   arg3 = (int)jarg3;
87989   {
87990     try {
87991       try {
87992         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
87993       }
87994       catch(std::out_of_range &_e) {
87995         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87996         return ;
87997       }
87998       catch(std::invalid_argument &_e) {
87999         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88000         return ;
88001       }
88002
88003     } catch (std::out_of_range& e) {
88004       {
88005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88006       };
88007     } catch (std::exception& e) {
88008       {
88009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88010       };
88011     } catch (...) {
88012       {
88013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88014       };
88015     }
88016   }
88017 }
88018
88019
88020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
88021   void * jresult ;
88022   Dali::Actor *arg1 = 0 ;
88023   int arg2 ;
88024   std::vector< Dali::Actor > *result = 0 ;
88025
88026   arg1 = (Dali::Actor *)jarg1;
88027   if (!arg1) {
88028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88029     return 0;
88030   }
88031   arg2 = (int)jarg2;
88032   {
88033     try {
88034       try {
88035         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
88036       }
88037       catch(std::out_of_range &_e) {
88038         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88039         return 0;
88040       }
88041
88042     } catch (std::out_of_range& e) {
88043       {
88044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88045       };
88046     } catch (std::exception& e) {
88047       {
88048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88049       };
88050     } catch (...) {
88051       {
88052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88053       };
88054     }
88055   }
88056   jresult = (void *)result;
88057   return jresult;
88058 }
88059
88060
88061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
88062   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88063
88064   arg1 = (std::vector< Dali::Actor > *)jarg1;
88065   {
88066     try {
88067       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
88068     } catch (std::out_of_range& e) {
88069       {
88070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88071       };
88072     } catch (std::exception& e) {
88073       {
88074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88075       };
88076     } catch (...) {
88077       {
88078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88079       };
88080     }
88081   }
88082 }
88083
88084
88085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
88086   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88087   int arg2 ;
88088   int arg3 ;
88089
88090   arg1 = (std::vector< Dali::Actor > *)jarg1;
88091   arg2 = (int)jarg2;
88092   arg3 = (int)jarg3;
88093   {
88094     try {
88095       try {
88096         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
88097       }
88098       catch(std::out_of_range &_e) {
88099         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88100         return ;
88101       }
88102       catch(std::invalid_argument &_e) {
88103         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88104         return ;
88105       }
88106
88107     } catch (std::out_of_range& e) {
88108       {
88109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88110       };
88111     } catch (std::exception& e) {
88112       {
88113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88114       };
88115     } catch (...) {
88116       {
88117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88118       };
88119     }
88120   }
88121 }
88122
88123
88124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
88125   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88126   int arg2 ;
88127   std::vector< Dali::Actor > *arg3 = 0 ;
88128
88129   arg1 = (std::vector< Dali::Actor > *)jarg1;
88130   arg2 = (int)jarg2;
88131   arg3 = (std::vector< Dali::Actor > *)jarg3;
88132   if (!arg3) {
88133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
88134     return ;
88135   }
88136   {
88137     try {
88138       try {
88139         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
88140       }
88141       catch(std::out_of_range &_e) {
88142         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88143         return ;
88144       }
88145
88146     } catch (std::out_of_range& e) {
88147       {
88148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88149       };
88150     } catch (std::exception& e) {
88151       {
88152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88153       };
88154     } catch (...) {
88155       {
88156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88157       };
88158     }
88159   }
88160 }
88161
88162
88163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
88164   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88165
88166   arg1 = (std::vector< Dali::Actor > *)jarg1;
88167   {
88168     try {
88169       delete arg1;
88170     } catch (std::out_of_range& e) {
88171       {
88172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88173       };
88174     } catch (std::exception& e) {
88175       {
88176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88177       };
88178     } catch (...) {
88179       {
88180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88181       };
88182     }
88183   }
88184 }
88185
88186
88187 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
88188   unsigned int jresult ;
88189   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88190   bool result;
88191
88192   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88193   {
88194     try {
88195       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
88196     } catch (std::out_of_range& e) {
88197       {
88198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88199       };
88200     } catch (std::exception& e) {
88201       {
88202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88203       };
88204     } catch (...) {
88205       {
88206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88207       };
88208     }
88209   }
88210   jresult = result;
88211   return jresult;
88212 }
88213
88214
88215 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
88216   unsigned long jresult ;
88217   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88218   std::size_t result;
88219
88220   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88221   {
88222     try {
88223       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
88224     } catch (std::out_of_range& e) {
88225       {
88226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88227       };
88228     } catch (std::exception& e) {
88229       {
88230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88231       };
88232     } catch (...) {
88233       {
88234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88235       };
88236     }
88237   }
88238   jresult = (unsigned long)result;
88239   return jresult;
88240 }
88241
88242
88243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
88244   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88245   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
88246
88247   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88248   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
88249   {
88250     try {
88251       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
88252     } catch (std::out_of_range& e) {
88253       {
88254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88255       };
88256     } catch (std::exception& e) {
88257       {
88258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88259       };
88260     } catch (...) {
88261       {
88262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88263       };
88264     }
88265   }
88266 }
88267
88268
88269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
88270   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88271   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
88272
88273   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88274   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
88275   {
88276     try {
88277       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
88278     } catch (std::out_of_range& e) {
88279       {
88280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88281       };
88282     } catch (std::exception& e) {
88283       {
88284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88285       };
88286     } catch (...) {
88287       {
88288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88289       };
88290     }
88291   }
88292 }
88293
88294
88295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
88296   unsigned int jresult ;
88297   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88298   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
88299   bool result;
88300
88301   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88302   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
88303   if (!arg2) {
88304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
88305     return 0;
88306   }
88307   {
88308     try {
88309       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
88310     } catch (std::out_of_range& e) {
88311       {
88312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88313       };
88314     } catch (std::exception& e) {
88315       {
88316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88317       };
88318     } catch (...) {
88319       {
88320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88321       };
88322     }
88323   }
88324   jresult = result;
88325   return jresult;
88326 }
88327
88328
88329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
88330   void * jresult ;
88331   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
88332
88333   {
88334     try {
88335       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
88336     } catch (std::out_of_range& e) {
88337       {
88338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88339       };
88340     } catch (std::exception& e) {
88341       {
88342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88343       };
88344     } catch (...) {
88345       {
88346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88347       };
88348     }
88349   }
88350   jresult = (void *)result;
88351   return jresult;
88352 }
88353
88354
88355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
88356   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88357
88358   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88359   {
88360     try {
88361       delete arg1;
88362     } catch (std::out_of_range& e) {
88363       {
88364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88365       };
88366     } catch (std::exception& e) {
88367       {
88368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88369       };
88370     } catch (...) {
88371       {
88372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88373       };
88374     }
88375   }
88376 }
88377
88378
88379 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
88380   unsigned int jresult ;
88381   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88382   bool result;
88383
88384   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88385   {
88386     try {
88387       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);
88388     } catch (std::out_of_range& e) {
88389       {
88390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88391       };
88392     } catch (std::exception& e) {
88393       {
88394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88395       };
88396     } catch (...) {
88397       {
88398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88399       };
88400     }
88401   }
88402   jresult = result;
88403   return jresult;
88404 }
88405
88406
88407 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
88408   unsigned long jresult ;
88409   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88410   std::size_t result;
88411
88412   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88413   {
88414     try {
88415       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);
88416     } catch (std::out_of_range& e) {
88417       {
88418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88419       };
88420     } catch (std::exception& e) {
88421       {
88422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88423       };
88424     } catch (...) {
88425       {
88426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88427       };
88428     }
88429   }
88430   jresult = (unsigned long)result;
88431   return jresult;
88432 }
88433
88434
88435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
88436   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88437   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
88438
88439   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88440   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
88441   {
88442     try {
88443       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
88444     } catch (std::out_of_range& e) {
88445       {
88446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88447       };
88448     } catch (std::exception& e) {
88449       {
88450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88451       };
88452     } catch (...) {
88453       {
88454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88455       };
88456     }
88457   }
88458 }
88459
88460
88461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
88462   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88463   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
88464
88465   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88466   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
88467   {
88468     try {
88469       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
88470     } catch (std::out_of_range& e) {
88471       {
88472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88473       };
88474     } catch (std::exception& e) {
88475       {
88476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88477       };
88478     } catch (...) {
88479       {
88480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88481       };
88482     }
88483   }
88484 }
88485
88486
88487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
88488   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88489   Dali::Actor arg2 ;
88490   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
88491   Dali::Actor *argp2 ;
88492
88493   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88494   argp2 = (Dali::Actor *)jarg2;
88495   if (!argp2) {
88496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88497     return ;
88498   }
88499   arg2 = *argp2;
88500   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
88501   {
88502     try {
88503       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
88504     } catch (std::out_of_range& e) {
88505       {
88506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88507       };
88508     } catch (std::exception& e) {
88509       {
88510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88511       };
88512     } catch (...) {
88513       {
88514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88515       };
88516     }
88517   }
88518 }
88519
88520
88521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
88522   void * jresult ;
88523   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
88524
88525   {
88526     try {
88527       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
88528     } catch (std::out_of_range& e) {
88529       {
88530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88531       };
88532     } catch (std::exception& e) {
88533       {
88534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88535       };
88536     } catch (...) {
88537       {
88538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88539       };
88540     }
88541   }
88542   jresult = (void *)result;
88543   return jresult;
88544 }
88545
88546
88547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
88548   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88549
88550   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88551   {
88552     try {
88553       delete arg1;
88554     } catch (std::out_of_range& e) {
88555       {
88556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88557       };
88558     } catch (std::exception& e) {
88559       {
88560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88561       };
88562     } catch (...) {
88563       {
88564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88565       };
88566     }
88567   }
88568 }
88569
88570
88571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
88572   unsigned int jresult ;
88573   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88574   bool result;
88575
88576   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88577   {
88578     try {
88579       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
88580     } catch (std::out_of_range& e) {
88581       {
88582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88583       };
88584     } catch (std::exception& e) {
88585       {
88586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88587       };
88588     } catch (...) {
88589       {
88590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88591       };
88592     }
88593   }
88594   jresult = result;
88595   return jresult;
88596 }
88597
88598
88599 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
88600   unsigned long jresult ;
88601   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88602   std::size_t result;
88603
88604   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88605   {
88606     try {
88607       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
88608     } catch (std::out_of_range& e) {
88609       {
88610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88611       };
88612     } catch (std::exception& e) {
88613       {
88614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88615       };
88616     } catch (...) {
88617       {
88618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88619       };
88620     }
88621   }
88622   jresult = (unsigned long)result;
88623   return jresult;
88624 }
88625
88626
88627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
88628   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88629   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
88630
88631   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88632   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
88633   {
88634     try {
88635       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
88636     } catch (std::out_of_range& e) {
88637       {
88638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88639       };
88640     } catch (std::exception& e) {
88641       {
88642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88643       };
88644     } catch (...) {
88645       {
88646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88647       };
88648     }
88649   }
88650 }
88651
88652
88653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
88654   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88655   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
88656
88657   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88658   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
88659   {
88660     try {
88661       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
88662     } catch (std::out_of_range& e) {
88663       {
88664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88665       };
88666     } catch (std::exception& e) {
88667       {
88668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88669       };
88670     } catch (...) {
88671       {
88672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88673       };
88674     }
88675   }
88676 }
88677
88678
88679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
88680   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88681   Dali::Actor arg2 ;
88682   Dali::Actor arg3 ;
88683   Dali::Actor *argp2 ;
88684   Dali::Actor *argp3 ;
88685
88686   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88687   argp2 = (Dali::Actor *)jarg2;
88688   if (!argp2) {
88689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88690     return ;
88691   }
88692   arg2 = *argp2;
88693   argp3 = (Dali::Actor *)jarg3;
88694   if (!argp3) {
88695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88696     return ;
88697   }
88698   arg3 = *argp3;
88699   {
88700     try {
88701       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
88702     } catch (std::out_of_range& e) {
88703       {
88704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88705       };
88706     } catch (std::exception& e) {
88707       {
88708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88709       };
88710     } catch (...) {
88711       {
88712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88713       };
88714     }
88715   }
88716 }
88717
88718
88719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
88720   void * jresult ;
88721   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
88722
88723   {
88724     try {
88725       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
88726     } catch (std::out_of_range& e) {
88727       {
88728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88729       };
88730     } catch (std::exception& e) {
88731       {
88732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88733       };
88734     } catch (...) {
88735       {
88736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88737       };
88738     }
88739   }
88740   jresult = (void *)result;
88741   return jresult;
88742 }
88743
88744
88745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
88746   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88747
88748   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88749   {
88750     try {
88751       delete arg1;
88752     } catch (std::out_of_range& e) {
88753       {
88754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88755       };
88756     } catch (std::exception& e) {
88757       {
88758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88759       };
88760     } catch (...) {
88761       {
88762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88763       };
88764     }
88765   }
88766 }
88767
88768
88769 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
88770   unsigned int jresult ;
88771   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88772   bool result;
88773
88774   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88775   {
88776     try {
88777       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
88778     } catch (std::out_of_range& e) {
88779       {
88780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88781       };
88782     } catch (std::exception& e) {
88783       {
88784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88785       };
88786     } catch (...) {
88787       {
88788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88789       };
88790     }
88791   }
88792   jresult = result;
88793   return jresult;
88794 }
88795
88796
88797 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
88798   unsigned long jresult ;
88799   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88800   std::size_t result;
88801
88802   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88803   {
88804     try {
88805       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
88806     } catch (std::out_of_range& e) {
88807       {
88808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88809       };
88810     } catch (std::exception& e) {
88811       {
88812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88813       };
88814     } catch (...) {
88815       {
88816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88817       };
88818     }
88819   }
88820   jresult = (unsigned long)result;
88821   return jresult;
88822 }
88823
88824
88825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
88826   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88827   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
88828
88829   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88830   arg2 = (void (*)(Dali::Actor,bool))jarg2;
88831   {
88832     try {
88833       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
88834     } catch (std::out_of_range& e) {
88835       {
88836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88837       };
88838     } catch (std::exception& e) {
88839       {
88840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88841       };
88842     } catch (...) {
88843       {
88844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88845       };
88846     }
88847   }
88848 }
88849
88850
88851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
88852   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88853   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
88854
88855   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88856   arg2 = (void (*)(Dali::Actor,bool))jarg2;
88857   {
88858     try {
88859       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
88860     } catch (std::out_of_range& e) {
88861       {
88862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88863       };
88864     } catch (std::exception& e) {
88865       {
88866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88867       };
88868     } catch (...) {
88869       {
88870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88871       };
88872     }
88873   }
88874 }
88875
88876
88877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
88878   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88879   Dali::Actor arg2 ;
88880   bool arg3 ;
88881   Dali::Actor *argp2 ;
88882
88883   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88884   argp2 = (Dali::Actor *)jarg2;
88885   if (!argp2) {
88886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88887     return ;
88888   }
88889   arg2 = *argp2;
88890   arg3 = jarg3 ? true : false;
88891   {
88892     try {
88893       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
88894     } catch (std::out_of_range& e) {
88895       {
88896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88897       };
88898     } catch (std::exception& e) {
88899       {
88900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88901       };
88902     } catch (...) {
88903       {
88904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88905       };
88906     }
88907   }
88908 }
88909
88910
88911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
88912   void * jresult ;
88913   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
88914
88915   {
88916     try {
88917       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
88918     } catch (std::out_of_range& e) {
88919       {
88920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88921       };
88922     } catch (std::exception& e) {
88923       {
88924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88925       };
88926     } catch (...) {
88927       {
88928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88929       };
88930     }
88931   }
88932   jresult = (void *)result;
88933   return jresult;
88934 }
88935
88936
88937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
88938   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88939
88940   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88941   {
88942     try {
88943       delete arg1;
88944     } catch (std::out_of_range& e) {
88945       {
88946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88947       };
88948     } catch (std::exception& e) {
88949       {
88950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88951       };
88952     } catch (...) {
88953       {
88954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88955       };
88956     }
88957   }
88958 }
88959
88960
88961 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
88962   unsigned int jresult ;
88963   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
88964   bool result;
88965
88966   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
88967   {
88968     try {
88969       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);
88970     } catch (std::out_of_range& e) {
88971       {
88972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88973       };
88974     } catch (std::exception& e) {
88975       {
88976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88977       };
88978     } catch (...) {
88979       {
88980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88981       };
88982     }
88983   }
88984   jresult = result;
88985   return jresult;
88986 }
88987
88988
88989 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
88990   unsigned long jresult ;
88991   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
88992   std::size_t result;
88993
88994   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
88995   {
88996     try {
88997       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);
88998     } catch (std::out_of_range& e) {
88999       {
89000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89001       };
89002     } catch (std::exception& e) {
89003       {
89004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89005       };
89006     } catch (...) {
89007       {
89008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89009       };
89010     }
89011   }
89012   jresult = (unsigned long)result;
89013   return jresult;
89014 }
89015
89016
89017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
89018   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89019   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
89020
89021   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89022   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
89023   {
89024     try {
89025       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
89026     } catch (std::out_of_range& e) {
89027       {
89028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89029       };
89030     } catch (std::exception& e) {
89031       {
89032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89033       };
89034     } catch (...) {
89035       {
89036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89037       };
89038     }
89039   }
89040 }
89041
89042
89043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
89044   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89045   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
89046
89047   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89048   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
89049   {
89050     try {
89051       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
89052     } catch (std::out_of_range& e) {
89053       {
89054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89055       };
89056     } catch (std::exception& e) {
89057       {
89058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89059       };
89060     } catch (...) {
89061       {
89062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89063       };
89064     }
89065   }
89066 }
89067
89068
89069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
89070   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89071   Dali::Toolkit::StyleManager arg2 ;
89072   Dali::StyleChange::Type arg3 ;
89073   Dali::Toolkit::StyleManager *argp2 ;
89074
89075   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89076   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
89077   if (!argp2) {
89078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
89079     return ;
89080   }
89081   arg2 = *argp2;
89082   arg3 = (Dali::StyleChange::Type)jarg3;
89083   {
89084     try {
89085       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
89086     } catch (std::out_of_range& e) {
89087       {
89088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89089       };
89090     } catch (std::exception& e) {
89091       {
89092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89093       };
89094     } catch (...) {
89095       {
89096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89097       };
89098     }
89099   }
89100 }
89101
89102
89103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
89104   void * jresult ;
89105   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
89106
89107   {
89108     try {
89109       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
89110     } catch (std::out_of_range& e) {
89111       {
89112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89113       };
89114     } catch (std::exception& e) {
89115       {
89116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89117       };
89118     } catch (...) {
89119       {
89120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89121       };
89122     }
89123   }
89124   jresult = (void *)result;
89125   return jresult;
89126 }
89127
89128
89129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
89130   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89131
89132   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89133   {
89134     try {
89135       delete arg1;
89136     } catch (std::out_of_range& e) {
89137       {
89138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89139       };
89140     } catch (std::exception& e) {
89141       {
89142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89143       };
89144     } catch (...) {
89145       {
89146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89147       };
89148     }
89149   }
89150 }
89151
89152
89153 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
89154   unsigned int jresult ;
89155   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89156   bool result;
89157
89158   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89159   {
89160     try {
89161       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
89162     } catch (std::out_of_range& e) {
89163       {
89164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89165       };
89166     } catch (std::exception& e) {
89167       {
89168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89169       };
89170     } catch (...) {
89171       {
89172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89173       };
89174     }
89175   }
89176   jresult = result;
89177   return jresult;
89178 }
89179
89180
89181 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
89182   unsigned long jresult ;
89183   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89184   std::size_t result;
89185
89186   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89187   {
89188     try {
89189       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
89190     } catch (std::out_of_range& e) {
89191       {
89192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89193       };
89194     } catch (std::exception& e) {
89195       {
89196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89197       };
89198     } catch (...) {
89199       {
89200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89201       };
89202     }
89203   }
89204   jresult = (unsigned long)result;
89205   return jresult;
89206 }
89207
89208
89209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
89210   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89211   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
89212
89213   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89214   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
89215   {
89216     try {
89217       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
89218     } catch (std::out_of_range& e) {
89219       {
89220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89221       };
89222     } catch (std::exception& e) {
89223       {
89224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89225       };
89226     } catch (...) {
89227       {
89228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89229       };
89230     }
89231   }
89232 }
89233
89234
89235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
89236   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89237   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
89238
89239   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89240   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
89241   {
89242     try {
89243       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
89244     } catch (std::out_of_range& e) {
89245       {
89246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89247       };
89248     } catch (std::exception& e) {
89249       {
89250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89251       };
89252     } catch (...) {
89253       {
89254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89255       };
89256     }
89257   }
89258 }
89259
89260
89261 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
89262   unsigned int jresult ;
89263   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89264   Dali::Toolkit::Button arg2 ;
89265   Dali::Toolkit::Button *argp2 ;
89266   bool result;
89267
89268   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89269   argp2 = (Dali::Toolkit::Button *)jarg2;
89270   if (!argp2) {
89271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
89272     return 0;
89273   }
89274   arg2 = *argp2;
89275   {
89276     try {
89277       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
89278     } catch (std::out_of_range& e) {
89279       {
89280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89281       };
89282     } catch (std::exception& e) {
89283       {
89284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89285       };
89286     } catch (...) {
89287       {
89288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89289       };
89290     }
89291   }
89292   jresult = result;
89293   return jresult;
89294 }
89295
89296
89297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
89298   void * jresult ;
89299   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
89300
89301   {
89302     try {
89303       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
89304     } catch (std::out_of_range& e) {
89305       {
89306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89307       };
89308     } catch (std::exception& e) {
89309       {
89310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89311       };
89312     } catch (...) {
89313       {
89314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89315       };
89316     }
89317   }
89318   jresult = (void *)result;
89319   return jresult;
89320 }
89321
89322
89323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
89324   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89325
89326   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89327   {
89328     try {
89329       delete arg1;
89330     } catch (std::out_of_range& e) {
89331       {
89332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89333       };
89334     } catch (std::exception& e) {
89335       {
89336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89337       };
89338     } catch (...) {
89339       {
89340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89341       };
89342     }
89343   }
89344 }
89345
89346
89347 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
89348   unsigned int jresult ;
89349   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89350   bool result;
89351
89352   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89353   {
89354     try {
89355       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
89356     } catch (std::out_of_range& e) {
89357       {
89358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89359       };
89360     } catch (std::exception& e) {
89361       {
89362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89363       };
89364     } catch (...) {
89365       {
89366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89367       };
89368     }
89369   }
89370   jresult = result;
89371   return jresult;
89372 }
89373
89374
89375 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
89376   unsigned long jresult ;
89377   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89378   std::size_t result;
89379
89380   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89381   {
89382     try {
89383       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
89384     } catch (std::out_of_range& e) {
89385       {
89386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89387       };
89388     } catch (std::exception& e) {
89389       {
89390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89391       };
89392     } catch (...) {
89393       {
89394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89395       };
89396     }
89397   }
89398   jresult = (unsigned long)result;
89399   return jresult;
89400 }
89401
89402
89403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
89404   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89405   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
89406
89407   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89408   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
89409   {
89410     try {
89411       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
89412     } catch (std::out_of_range& e) {
89413       {
89414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89415       };
89416     } catch (std::exception& e) {
89417       {
89418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89419       };
89420     } catch (...) {
89421       {
89422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89423       };
89424     }
89425   }
89426 }
89427
89428
89429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
89430   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89431   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
89432
89433   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89434   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
89435   {
89436     try {
89437       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
89438     } catch (std::out_of_range& e) {
89439       {
89440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89441       };
89442     } catch (std::exception& e) {
89443       {
89444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89445       };
89446     } catch (...) {
89447       {
89448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89449       };
89450     }
89451   }
89452 }
89453
89454
89455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
89456   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89457   Dali::Toolkit::GaussianBlurView arg2 ;
89458   Dali::Toolkit::GaussianBlurView *argp2 ;
89459
89460   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89461   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
89462   if (!argp2) {
89463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
89464     return ;
89465   }
89466   arg2 = *argp2;
89467   {
89468     try {
89469       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
89470     } catch (std::out_of_range& e) {
89471       {
89472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89473       };
89474     } catch (std::exception& e) {
89475       {
89476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89477       };
89478     } catch (...) {
89479       {
89480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89481       };
89482     }
89483   }
89484 }
89485
89486
89487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
89488   void * jresult ;
89489   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
89490
89491   {
89492     try {
89493       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
89494     } catch (std::out_of_range& e) {
89495       {
89496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89497       };
89498     } catch (std::exception& e) {
89499       {
89500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89501       };
89502     } catch (...) {
89503       {
89504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89505       };
89506     }
89507   }
89508   jresult = (void *)result;
89509   return jresult;
89510 }
89511
89512
89513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
89514   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89515
89516   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89517   {
89518     try {
89519       delete arg1;
89520     } catch (std::out_of_range& e) {
89521       {
89522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89523       };
89524     } catch (std::exception& e) {
89525       {
89526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89527       };
89528     } catch (...) {
89529       {
89530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89531       };
89532     }
89533   }
89534 }
89535
89536
89537 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
89538   unsigned int jresult ;
89539   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89540   bool result;
89541
89542   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89543   {
89544     try {
89545       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);
89546     } catch (std::out_of_range& e) {
89547       {
89548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89549       };
89550     } catch (std::exception& e) {
89551       {
89552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89553       };
89554     } catch (...) {
89555       {
89556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89557       };
89558     }
89559   }
89560   jresult = result;
89561   return jresult;
89562 }
89563
89564
89565 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
89566   unsigned long jresult ;
89567   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89568   std::size_t result;
89569
89570   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89571   {
89572     try {
89573       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);
89574     } catch (std::out_of_range& e) {
89575       {
89576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89577       };
89578     } catch (std::exception& e) {
89579       {
89580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89581       };
89582     } catch (...) {
89583       {
89584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89585       };
89586     }
89587   }
89588   jresult = (unsigned long)result;
89589   return jresult;
89590 }
89591
89592
89593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
89594   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89595   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
89596
89597   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89598   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
89599   {
89600     try {
89601       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
89602     } catch (std::out_of_range& e) {
89603       {
89604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89605       };
89606     } catch (std::exception& e) {
89607       {
89608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89609       };
89610     } catch (...) {
89611       {
89612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89613       };
89614     }
89615   }
89616 }
89617
89618
89619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
89620   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89621   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
89622
89623   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89624   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
89625   {
89626     try {
89627       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
89628     } catch (std::out_of_range& e) {
89629       {
89630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89631       };
89632     } catch (std::exception& e) {
89633       {
89634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89635       };
89636     } catch (...) {
89637       {
89638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89639       };
89640     }
89641   }
89642 }
89643
89644
89645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
89646   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89647   Dali::Toolkit::PageTurnView arg2 ;
89648   unsigned int arg3 ;
89649   bool arg4 ;
89650   Dali::Toolkit::PageTurnView *argp2 ;
89651
89652   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89653   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
89654   if (!argp2) {
89655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
89656     return ;
89657   }
89658   arg2 = *argp2;
89659   arg3 = (unsigned int)jarg3;
89660   arg4 = jarg4 ? true : false;
89661   {
89662     try {
89663       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
89664     } catch (std::out_of_range& e) {
89665       {
89666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89667       };
89668     } catch (std::exception& e) {
89669       {
89670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89671       };
89672     } catch (...) {
89673       {
89674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89675       };
89676     }
89677   }
89678 }
89679
89680
89681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
89682   void * jresult ;
89683   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
89684
89685   {
89686     try {
89687       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
89688     } catch (std::out_of_range& e) {
89689       {
89690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89691       };
89692     } catch (std::exception& e) {
89693       {
89694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89695       };
89696     } catch (...) {
89697       {
89698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89699       };
89700     }
89701   }
89702   jresult = (void *)result;
89703   return jresult;
89704 }
89705
89706
89707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
89708   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89709
89710   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89711   {
89712     try {
89713       delete arg1;
89714     } catch (std::out_of_range& e) {
89715       {
89716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89717       };
89718     } catch (std::exception& e) {
89719       {
89720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89721       };
89722     } catch (...) {
89723       {
89724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89725       };
89726     }
89727   }
89728 }
89729
89730
89731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
89732   unsigned int jresult ;
89733   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89734   bool result;
89735
89736   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89737   {
89738     try {
89739       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
89740     } catch (std::out_of_range& e) {
89741       {
89742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89743       };
89744     } catch (std::exception& e) {
89745       {
89746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89747       };
89748     } catch (...) {
89749       {
89750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89751       };
89752     }
89753   }
89754   jresult = result;
89755   return jresult;
89756 }
89757
89758
89759 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
89760   unsigned long jresult ;
89761   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89762   std::size_t result;
89763
89764   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89765   {
89766     try {
89767       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
89768     } catch (std::out_of_range& e) {
89769       {
89770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89771       };
89772     } catch (std::exception& e) {
89773       {
89774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89775       };
89776     } catch (...) {
89777       {
89778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89779       };
89780     }
89781   }
89782   jresult = (unsigned long)result;
89783   return jresult;
89784 }
89785
89786
89787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
89788   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89789   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
89790
89791   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89792   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
89793   {
89794     try {
89795       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
89796     } catch (std::out_of_range& e) {
89797       {
89798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89799       };
89800     } catch (std::exception& e) {
89801       {
89802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89803       };
89804     } catch (...) {
89805       {
89806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89807       };
89808     }
89809   }
89810 }
89811
89812
89813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
89814   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89815   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
89816
89817   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89818   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
89819   {
89820     try {
89821       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
89822     } catch (std::out_of_range& e) {
89823       {
89824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89825       };
89826     } catch (std::exception& e) {
89827       {
89828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89829       };
89830     } catch (...) {
89831       {
89832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89833       };
89834     }
89835   }
89836 }
89837
89838
89839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
89840   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89841   Dali::Toolkit::PageTurnView arg2 ;
89842   Dali::Toolkit::PageTurnView *argp2 ;
89843
89844   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89845   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
89846   if (!argp2) {
89847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
89848     return ;
89849   }
89850   arg2 = *argp2;
89851   {
89852     try {
89853       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
89854     } catch (std::out_of_range& e) {
89855       {
89856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89857       };
89858     } catch (std::exception& e) {
89859       {
89860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89861       };
89862     } catch (...) {
89863       {
89864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89865       };
89866     }
89867   }
89868 }
89869
89870
89871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
89872   void * jresult ;
89873   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
89874
89875   {
89876     try {
89877       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
89878     } catch (std::out_of_range& e) {
89879       {
89880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89881       };
89882     } catch (std::exception& e) {
89883       {
89884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89885       };
89886     } catch (...) {
89887       {
89888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89889       };
89890     }
89891   }
89892   jresult = (void *)result;
89893   return jresult;
89894 }
89895
89896
89897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
89898   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89899
89900   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89901   {
89902     try {
89903       delete arg1;
89904     } catch (std::out_of_range& e) {
89905       {
89906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89907       };
89908     } catch (std::exception& e) {
89909       {
89910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89911       };
89912     } catch (...) {
89913       {
89914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89915       };
89916     }
89917   }
89918 }
89919
89920
89921 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
89922   unsigned int jresult ;
89923   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
89924   bool result;
89925
89926   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
89927   {
89928     try {
89929       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);
89930     } catch (std::out_of_range& e) {
89931       {
89932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89933       };
89934     } catch (std::exception& e) {
89935       {
89936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89937       };
89938     } catch (...) {
89939       {
89940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89941       };
89942     }
89943   }
89944   jresult = result;
89945   return jresult;
89946 }
89947
89948
89949 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
89950   unsigned long jresult ;
89951   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
89952   std::size_t result;
89953
89954   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
89955   {
89956     try {
89957       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);
89958     } catch (std::out_of_range& e) {
89959       {
89960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89961       };
89962     } catch (std::exception& e) {
89963       {
89964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89965       };
89966     } catch (...) {
89967       {
89968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89969       };
89970     }
89971   }
89972   jresult = (unsigned long)result;
89973   return jresult;
89974 }
89975
89976
89977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
89978   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
89979   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
89980
89981   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
89982   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
89983   {
89984     try {
89985       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
89986     } catch (std::out_of_range& e) {
89987       {
89988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89989       };
89990     } catch (std::exception& e) {
89991       {
89992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89993       };
89994     } catch (...) {
89995       {
89996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89997       };
89998     }
89999   }
90000 }
90001
90002
90003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90004   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
90005   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
90006
90007   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
90008   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
90009   {
90010     try {
90011       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
90012     } catch (std::out_of_range& e) {
90013       {
90014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90015       };
90016     } catch (std::exception& e) {
90017       {
90018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90019       };
90020     } catch (...) {
90021       {
90022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90023       };
90024     }
90025   }
90026 }
90027
90028
90029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
90030   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
90031   Dali::Toolkit::ProgressBar arg2 ;
90032   float arg3 ;
90033   float arg4 ;
90034   Dali::Toolkit::ProgressBar *argp2 ;
90035
90036   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
90037   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
90038   if (!argp2) {
90039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
90040     return ;
90041   }
90042   arg2 = *argp2;
90043   arg3 = (float)jarg3;
90044   arg4 = (float)jarg4;
90045   {
90046     try {
90047       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
90048     } catch (std::out_of_range& e) {
90049       {
90050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90051       };
90052     } catch (std::exception& e) {
90053       {
90054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90055       };
90056     } catch (...) {
90057       {
90058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90059       };
90060     }
90061   }
90062 }
90063
90064
90065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
90066   void * jresult ;
90067   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
90068
90069   {
90070     try {
90071       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
90072     } catch (std::out_of_range& e) {
90073       {
90074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90075       };
90076     } catch (std::exception& e) {
90077       {
90078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90079       };
90080     } catch (...) {
90081       {
90082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90083       };
90084     }
90085   }
90086   jresult = (void *)result;
90087   return jresult;
90088 }
90089
90090
90091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
90092   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
90093
90094   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
90095   {
90096     try {
90097       delete arg1;
90098     } catch (std::out_of_range& e) {
90099       {
90100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90101       };
90102     } catch (std::exception& e) {
90103       {
90104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90105       };
90106     } catch (...) {
90107       {
90108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90109       };
90110     }
90111   }
90112 }
90113
90114
90115 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
90116   unsigned int jresult ;
90117   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90118   bool result;
90119
90120   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90121   {
90122     try {
90123       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);
90124     } catch (std::out_of_range& e) {
90125       {
90126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90127       };
90128     } catch (std::exception& e) {
90129       {
90130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90131       };
90132     } catch (...) {
90133       {
90134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90135       };
90136     }
90137   }
90138   jresult = result;
90139   return jresult;
90140 }
90141
90142
90143 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
90144   unsigned long jresult ;
90145   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90146   std::size_t result;
90147
90148   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90149   {
90150     try {
90151       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);
90152     } catch (std::out_of_range& e) {
90153       {
90154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90155       };
90156     } catch (std::exception& e) {
90157       {
90158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90159       };
90160     } catch (...) {
90161       {
90162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90163       };
90164     }
90165   }
90166   jresult = (unsigned long)result;
90167   return jresult;
90168 }
90169
90170
90171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
90172   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90173   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
90174
90175   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90176   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
90177   {
90178     try {
90179       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
90180     } catch (std::out_of_range& e) {
90181       {
90182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90183       };
90184     } catch (std::exception& e) {
90185       {
90186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90187       };
90188     } catch (...) {
90189       {
90190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90191       };
90192     }
90193   }
90194 }
90195
90196
90197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
90198   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90199   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
90200
90201   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90202   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
90203   {
90204     try {
90205       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
90206     } catch (std::out_of_range& e) {
90207       {
90208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90209       };
90210     } catch (std::exception& e) {
90211       {
90212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90213       };
90214     } catch (...) {
90215       {
90216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90217       };
90218     }
90219   }
90220 }
90221
90222
90223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
90224   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90225   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
90226
90227   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90228   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
90229   if (!arg2) {
90230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
90231     return ;
90232   }
90233   {
90234     try {
90235       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
90236     } catch (std::out_of_range& e) {
90237       {
90238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90239       };
90240     } catch (std::exception& e) {
90241       {
90242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90243       };
90244     } catch (...) {
90245       {
90246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90247       };
90248     }
90249   }
90250 }
90251
90252
90253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
90254   void * jresult ;
90255   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
90256
90257   {
90258     try {
90259       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
90260     } catch (std::out_of_range& e) {
90261       {
90262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90263       };
90264     } catch (std::exception& e) {
90265       {
90266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90267       };
90268     } catch (...) {
90269       {
90270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90271       };
90272     }
90273   }
90274   jresult = (void *)result;
90275   return jresult;
90276 }
90277
90278
90279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
90280   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90281
90282   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90283   {
90284     try {
90285       delete arg1;
90286     } catch (std::out_of_range& e) {
90287       {
90288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90289       };
90290     } catch (std::exception& e) {
90291       {
90292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90293       };
90294     } catch (...) {
90295       {
90296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90297       };
90298     }
90299   }
90300 }
90301
90302
90303 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
90304   unsigned int jresult ;
90305   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90306   bool result;
90307
90308   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90309   {
90310     try {
90311       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
90312     } catch (std::out_of_range& e) {
90313       {
90314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90315       };
90316     } catch (std::exception& e) {
90317       {
90318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90319       };
90320     } catch (...) {
90321       {
90322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90323       };
90324     }
90325   }
90326   jresult = result;
90327   return jresult;
90328 }
90329
90330
90331 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
90332   unsigned long jresult ;
90333   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90334   std::size_t result;
90335
90336   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90337   {
90338     try {
90339       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
90340     } catch (std::out_of_range& e) {
90341       {
90342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90343       };
90344     } catch (std::exception& e) {
90345       {
90346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90347       };
90348     } catch (...) {
90349       {
90350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90351       };
90352     }
90353   }
90354   jresult = (unsigned long)result;
90355   return jresult;
90356 }
90357
90358
90359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
90360   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90361   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
90362
90363   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90364   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
90365   {
90366     try {
90367       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
90368     } catch (std::out_of_range& e) {
90369       {
90370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90371       };
90372     } catch (std::exception& e) {
90373       {
90374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90375       };
90376     } catch (...) {
90377       {
90378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90379       };
90380     }
90381   }
90382 }
90383
90384
90385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
90386   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90387   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
90388
90389   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90390   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
90391   {
90392     try {
90393       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
90394     } catch (std::out_of_range& e) {
90395       {
90396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90397       };
90398     } catch (std::exception& e) {
90399       {
90400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90401       };
90402     } catch (...) {
90403       {
90404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90405       };
90406     }
90407   }
90408 }
90409
90410
90411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
90412   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90413   Dali::Vector2 *arg2 = 0 ;
90414
90415   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90416   arg2 = (Dali::Vector2 *)jarg2;
90417   if (!arg2) {
90418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90419     return ;
90420   }
90421   {
90422     try {
90423       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
90424     } catch (std::out_of_range& e) {
90425       {
90426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90427       };
90428     } catch (std::exception& e) {
90429       {
90430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90431       };
90432     } catch (...) {
90433       {
90434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90435       };
90436     }
90437   }
90438 }
90439
90440
90441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
90442   void * jresult ;
90443   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
90444
90445   {
90446     try {
90447       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
90448     } catch (std::out_of_range& e) {
90449       {
90450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90451       };
90452     } catch (std::exception& e) {
90453       {
90454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90455       };
90456     } catch (...) {
90457       {
90458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90459       };
90460     }
90461   }
90462   jresult = (void *)result;
90463   return jresult;
90464 }
90465
90466
90467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
90468   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90469
90470   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90471   {
90472     try {
90473       delete arg1;
90474     } catch (std::out_of_range& e) {
90475       {
90476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90477       };
90478     } catch (std::exception& e) {
90479       {
90480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90481       };
90482     } catch (...) {
90483       {
90484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90485       };
90486     }
90487   }
90488 }
90489
90490
90491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextEditorSignal_Empty(void * jarg1) {
90492   unsigned int jresult ;
90493   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90494   bool result;
90495
90496   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90497   {
90498     try {
90499       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
90500     } catch (std::out_of_range& e) {
90501       {
90502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90503       };
90504     } catch (std::exception& e) {
90505       {
90506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90507       };
90508     } catch (...) {
90509       {
90510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90511       };
90512     }
90513   }
90514   jresult = result;
90515   return jresult;
90516 }
90517
90518
90519 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextEditorSignal_GetConnectionCount(void * jarg1) {
90520   unsigned long jresult ;
90521   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90522   std::size_t result;
90523
90524   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90525   {
90526     try {
90527       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
90528     } catch (std::out_of_range& e) {
90529       {
90530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90531       };
90532     } catch (std::exception& e) {
90533       {
90534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90535       };
90536     } catch (...) {
90537       {
90538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90539       };
90540     }
90541   }
90542   jresult = (unsigned long)result;
90543   return jresult;
90544 }
90545
90546
90547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Connect(void * jarg1, void * jarg2) {
90548   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90549   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
90550
90551   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90552   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
90553   {
90554     try {
90555       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Connect(arg1,arg2);
90556     } catch (std::out_of_range& e) {
90557       {
90558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90559       };
90560     } catch (std::exception& e) {
90561       {
90562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90563       };
90564     } catch (...) {
90565       {
90566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90567       };
90568     }
90569   }
90570 }
90571
90572
90573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Disconnect(void * jarg1, void * jarg2) {
90574   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90575   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
90576
90577   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90578   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
90579   {
90580     try {
90581       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Disconnect(arg1,arg2);
90582     } catch (std::out_of_range& e) {
90583       {
90584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90585       };
90586     } catch (std::exception& e) {
90587       {
90588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90589       };
90590     } catch (...) {
90591       {
90592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90593       };
90594     }
90595   }
90596 }
90597
90598
90599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Emit(void * jarg1, void * jarg2) {
90600   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90601   Dali::Toolkit::TextEditor arg2 ;
90602   Dali::Toolkit::TextEditor *argp2 ;
90603
90604   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90605   argp2 = (Dali::Toolkit::TextEditor *)jarg2;
90606   if (!argp2) {
90607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextEditor", 0);
90608     return ;
90609   }
90610   arg2 = *argp2;
90611   {
90612     try {
90613       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(arg1,arg2);
90614     } catch (std::out_of_range& e) {
90615       {
90616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90617       };
90618     } catch (std::exception& e) {
90619       {
90620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90621       };
90622     } catch (...) {
90623       {
90624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90625       };
90626     }
90627   }
90628 }
90629
90630
90631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditorSignal() {
90632   void * jresult ;
90633   Dali::Signal< void (Dali::Toolkit::TextEditor) > *result = 0 ;
90634
90635   {
90636     try {
90637       result = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)new Dali::Signal< void (Dali::Toolkit::TextEditor) >();
90638     } catch (std::out_of_range& e) {
90639       {
90640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90641       };
90642     } catch (std::exception& e) {
90643       {
90644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90645       };
90646     } catch (...) {
90647       {
90648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90649       };
90650     }
90651   }
90652   jresult = (void *)result;
90653   return jresult;
90654 }
90655
90656
90657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditorSignal(void * jarg1) {
90658   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90659
90660   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90661   {
90662     try {
90663       delete arg1;
90664     } catch (std::out_of_range& e) {
90665       {
90666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90667       };
90668     } catch (std::exception& e) {
90669       {
90670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90671       };
90672     } catch (...) {
90673       {
90674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90675       };
90676     }
90677   }
90678 }
90679
90680
90681 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextFieldSignal_Empty(void * jarg1) {
90682   unsigned int jresult ;
90683   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90684   bool result;
90685
90686   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90687   {
90688     try {
90689       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
90690     } catch (std::out_of_range& e) {
90691       {
90692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90693       };
90694     } catch (std::exception& e) {
90695       {
90696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90697       };
90698     } catch (...) {
90699       {
90700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90701       };
90702     }
90703   }
90704   jresult = result;
90705   return jresult;
90706 }
90707
90708
90709 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextFieldSignal_GetConnectionCount(void * jarg1) {
90710   unsigned long jresult ;
90711   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90712   std::size_t result;
90713
90714   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90715   {
90716     try {
90717       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
90718     } catch (std::out_of_range& e) {
90719       {
90720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90721       };
90722     } catch (std::exception& e) {
90723       {
90724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90725       };
90726     } catch (...) {
90727       {
90728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90729       };
90730     }
90731   }
90732   jresult = (unsigned long)result;
90733   return jresult;
90734 }
90735
90736
90737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Connect(void * jarg1, void * jarg2) {
90738   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90739   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
90740
90741   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90742   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
90743   {
90744     try {
90745       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Connect(arg1,arg2);
90746     } catch (std::out_of_range& e) {
90747       {
90748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90749       };
90750     } catch (std::exception& e) {
90751       {
90752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90753       };
90754     } catch (...) {
90755       {
90756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90757       };
90758     }
90759   }
90760 }
90761
90762
90763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Disconnect(void * jarg1, void * jarg2) {
90764   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90765   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
90766
90767   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90768   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
90769   {
90770     try {
90771       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Disconnect(arg1,arg2);
90772     } catch (std::out_of_range& e) {
90773       {
90774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90775       };
90776     } catch (std::exception& e) {
90777       {
90778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90779       };
90780     } catch (...) {
90781       {
90782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90783       };
90784     }
90785   }
90786 }
90787
90788
90789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Emit(void * jarg1, void * jarg2) {
90790   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90791   Dali::Toolkit::TextField arg2 ;
90792   Dali::Toolkit::TextField *argp2 ;
90793
90794   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90795   argp2 = (Dali::Toolkit::TextField *)jarg2;
90796   if (!argp2) {
90797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextField", 0);
90798     return ;
90799   }
90800   arg2 = *argp2;
90801   {
90802     try {
90803       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(arg1,arg2);
90804     } catch (std::out_of_range& e) {
90805       {
90806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90807       };
90808     } catch (std::exception& e) {
90809       {
90810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90811       };
90812     } catch (...) {
90813       {
90814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90815       };
90816     }
90817   }
90818 }
90819
90820
90821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextFieldSignal() {
90822   void * jresult ;
90823   Dali::Signal< void (Dali::Toolkit::TextField) > *result = 0 ;
90824
90825   {
90826     try {
90827       result = (Dali::Signal< void (Dali::Toolkit::TextField) > *)new Dali::Signal< void (Dali::Toolkit::TextField) >();
90828     } catch (std::out_of_range& e) {
90829       {
90830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90831       };
90832     } catch (std::exception& e) {
90833       {
90834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90835       };
90836     } catch (...) {
90837       {
90838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90839       };
90840     }
90841   }
90842   jresult = (void *)result;
90843   return jresult;
90844 }
90845
90846
90847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextFieldSignal(void * jarg1) {
90848   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90849
90850   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90851   {
90852     try {
90853       delete arg1;
90854     } catch (std::out_of_range& e) {
90855       {
90856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90857       };
90858     } catch (std::exception& e) {
90859       {
90860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90861       };
90862     } catch (...) {
90863       {
90864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90865       };
90866     }
90867   }
90868 }
90869
90870
90871 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
90872   unsigned int jresult ;
90873   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90874   bool result;
90875
90876   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90877   {
90878     try {
90879       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);
90880     } catch (std::out_of_range& e) {
90881       {
90882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90883       };
90884     } catch (std::exception& e) {
90885       {
90886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90887       };
90888     } catch (...) {
90889       {
90890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90891       };
90892     }
90893   }
90894   jresult = result;
90895   return jresult;
90896 }
90897
90898
90899 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
90900   unsigned long jresult ;
90901   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90902   std::size_t result;
90903
90904   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90905   {
90906     try {
90907       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);
90908     } catch (std::out_of_range& e) {
90909       {
90910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90911       };
90912     } catch (std::exception& e) {
90913       {
90914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90915       };
90916     } catch (...) {
90917       {
90918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90919       };
90920     }
90921   }
90922   jresult = (unsigned long)result;
90923   return jresult;
90924 }
90925
90926
90927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
90928   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90929   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
90930
90931   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90932   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
90933   {
90934     try {
90935       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
90936     } catch (std::out_of_range& e) {
90937       {
90938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90939       };
90940     } catch (std::exception& e) {
90941       {
90942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90943       };
90944     } catch (...) {
90945       {
90946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90947       };
90948     }
90949   }
90950 }
90951
90952
90953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
90954   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90955   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
90956
90957   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90958   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
90959   {
90960     try {
90961       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
90962     } catch (std::out_of_range& e) {
90963       {
90964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90965       };
90966     } catch (std::exception& e) {
90967       {
90968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90969       };
90970     } catch (...) {
90971       {
90972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90973       };
90974     }
90975   }
90976 }
90977
90978
90979 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
90980   unsigned int jresult ;
90981   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90982   Dali::Toolkit::Control arg2 ;
90983   Dali::KeyEvent *arg3 = 0 ;
90984   Dali::Toolkit::Control *argp2 ;
90985   bool result;
90986
90987   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90988   argp2 = (Dali::Toolkit::Control *)jarg2;
90989   if (!argp2) {
90990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
90991     return 0;
90992   }
90993   arg2 = *argp2;
90994   arg3 = (Dali::KeyEvent *)jarg3;
90995   if (!arg3) {
90996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
90997     return 0;
90998   }
90999   {
91000     try {
91001       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);
91002     } catch (std::out_of_range& e) {
91003       {
91004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91005       };
91006     } catch (std::exception& e) {
91007       {
91008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91009       };
91010     } catch (...) {
91011       {
91012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91013       };
91014     }
91015   }
91016   jresult = result;
91017   return jresult;
91018 }
91019
91020
91021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
91022   void * jresult ;
91023   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
91024
91025   {
91026     try {
91027       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
91028     } catch (std::out_of_range& e) {
91029       {
91030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91031       };
91032     } catch (std::exception& e) {
91033       {
91034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91035       };
91036     } catch (...) {
91037       {
91038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91039       };
91040     }
91041   }
91042   jresult = (void *)result;
91043   return jresult;
91044 }
91045
91046
91047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
91048   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91049
91050   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91051   {
91052     try {
91053       delete arg1;
91054     } catch (std::out_of_range& e) {
91055       {
91056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91057       };
91058     } catch (std::exception& e) {
91059       {
91060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91061       };
91062     } catch (...) {
91063       {
91064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91065       };
91066     }
91067   }
91068 }
91069
91070
91071 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
91072   unsigned int jresult ;
91073   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91074   bool result;
91075
91076   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91077   {
91078     try {
91079       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
91080     } catch (std::out_of_range& e) {
91081       {
91082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91083       };
91084     } catch (std::exception& e) {
91085       {
91086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91087       };
91088     } catch (...) {
91089       {
91090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91091       };
91092     }
91093   }
91094   jresult = result;
91095   return jresult;
91096 }
91097
91098
91099 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
91100   unsigned long jresult ;
91101   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91102   std::size_t result;
91103
91104   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91105   {
91106     try {
91107       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
91108     } catch (std::out_of_range& e) {
91109       {
91110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91111       };
91112     } catch (std::exception& e) {
91113       {
91114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91115       };
91116     } catch (...) {
91117       {
91118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91119       };
91120     }
91121   }
91122   jresult = (unsigned long)result;
91123   return jresult;
91124 }
91125
91126
91127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
91128   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91129   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
91130
91131   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91132   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
91133   {
91134     try {
91135       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
91136     } catch (std::out_of_range& e) {
91137       {
91138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91139       };
91140     } catch (std::exception& e) {
91141       {
91142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91143       };
91144     } catch (...) {
91145       {
91146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91147       };
91148     }
91149   }
91150 }
91151
91152
91153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
91154   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91155   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
91156
91157   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91158   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
91159   {
91160     try {
91161       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
91162     } catch (std::out_of_range& e) {
91163       {
91164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91165       };
91166     } catch (std::exception& e) {
91167       {
91168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91169       };
91170     } catch (...) {
91171       {
91172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91173       };
91174     }
91175   }
91176 }
91177
91178
91179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
91180   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91181   Dali::Toolkit::Control arg2 ;
91182   Dali::Toolkit::Control *argp2 ;
91183
91184   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91185   argp2 = (Dali::Toolkit::Control *)jarg2;
91186   if (!argp2) {
91187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
91188     return ;
91189   }
91190   arg2 = *argp2;
91191   {
91192     try {
91193       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
91194     } catch (std::out_of_range& e) {
91195       {
91196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91197       };
91198     } catch (std::exception& e) {
91199       {
91200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91201       };
91202     } catch (...) {
91203       {
91204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91205       };
91206     }
91207   }
91208 }
91209
91210
91211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
91212   void * jresult ;
91213   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
91214
91215   {
91216     try {
91217       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
91218     } catch (std::out_of_range& e) {
91219       {
91220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91221       };
91222     } catch (std::exception& e) {
91223       {
91224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91225       };
91226     } catch (...) {
91227       {
91228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91229       };
91230     }
91231   }
91232   jresult = (void *)result;
91233   return jresult;
91234 }
91235
91236
91237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
91238   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91239
91240   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91241   {
91242     try {
91243       delete arg1;
91244     } catch (std::out_of_range& e) {
91245       {
91246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91247       };
91248     } catch (std::exception& e) {
91249       {
91250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91251       };
91252     } catch (...) {
91253       {
91254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91255       };
91256     }
91257   }
91258 }
91259
91260
91261 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
91262   unsigned int jresult ;
91263   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91264   bool result;
91265
91266   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91267   {
91268     try {
91269       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
91270     } catch (std::out_of_range& e) {
91271       {
91272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91273       };
91274     } catch (std::exception& e) {
91275       {
91276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91277       };
91278     } catch (...) {
91279       {
91280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91281       };
91282     }
91283   }
91284   jresult = result;
91285   return jresult;
91286 }
91287
91288
91289 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
91290   unsigned long jresult ;
91291   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91292   std::size_t result;
91293
91294   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91295   {
91296     try {
91297       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
91298     } catch (std::out_of_range& e) {
91299       {
91300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91301       };
91302     } catch (std::exception& e) {
91303       {
91304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91305       };
91306     } catch (...) {
91307       {
91308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91309       };
91310     }
91311   }
91312   jresult = (unsigned long)result;
91313   return jresult;
91314 }
91315
91316
91317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
91318   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91319   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
91320
91321   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91322   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
91323   {
91324     try {
91325       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
91326     } catch (std::out_of_range& e) {
91327       {
91328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91329       };
91330     } catch (std::exception& e) {
91331       {
91332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91333       };
91334     } catch (...) {
91335       {
91336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91337       };
91338     }
91339   }
91340 }
91341
91342
91343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
91344   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91345   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
91346
91347   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91348   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
91349   {
91350     try {
91351       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
91352     } catch (std::out_of_range& e) {
91353       {
91354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91355       };
91356     } catch (std::exception& e) {
91357       {
91358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91359       };
91360     } catch (...) {
91361       {
91362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91363       };
91364     }
91365   }
91366 }
91367
91368
91369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
91370   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91371   Dali::Toolkit::VideoView *arg2 = 0 ;
91372
91373   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91374   arg2 = (Dali::Toolkit::VideoView *)jarg2;
91375   if (!arg2) {
91376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
91377     return ;
91378   }
91379   {
91380     try {
91381       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
91382     } catch (std::out_of_range& e) {
91383       {
91384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91385       };
91386     } catch (std::exception& e) {
91387       {
91388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91389       };
91390     } catch (...) {
91391       {
91392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91393       };
91394     }
91395   }
91396 }
91397
91398
91399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
91400   void * jresult ;
91401   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
91402
91403   {
91404     try {
91405       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
91406     } catch (std::out_of_range& e) {
91407       {
91408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91409       };
91410     } catch (std::exception& e) {
91411       {
91412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91413       };
91414     } catch (...) {
91415       {
91416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91417       };
91418     }
91419   }
91420   jresult = (void *)result;
91421   return jresult;
91422 }
91423
91424
91425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
91426   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91427
91428   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91429   {
91430     try {
91431       delete arg1;
91432     } catch (std::out_of_range& e) {
91433       {
91434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91435       };
91436     } catch (std::exception& e) {
91437       {
91438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91439       };
91440     } catch (...) {
91441       {
91442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91443       };
91444     }
91445   }
91446 }
91447
91448
91449 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
91450   unsigned int jresult ;
91451   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91452   bool result;
91453
91454   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91455   {
91456     try {
91457       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
91458     } catch (std::out_of_range& e) {
91459       {
91460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91461       };
91462     } catch (std::exception& e) {
91463       {
91464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91465       };
91466     } catch (...) {
91467       {
91468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91469       };
91470     }
91471   }
91472   jresult = result;
91473   return jresult;
91474 }
91475
91476
91477 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
91478   unsigned long jresult ;
91479   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91480   std::size_t result;
91481
91482   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91483   {
91484     try {
91485       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
91486     } catch (std::out_of_range& e) {
91487       {
91488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91489       };
91490     } catch (std::exception& e) {
91491       {
91492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91493       };
91494     } catch (...) {
91495       {
91496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91497       };
91498     }
91499   }
91500   jresult = (unsigned long)result;
91501   return jresult;
91502 }
91503
91504
91505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
91506   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91507   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
91508
91509   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91510   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
91511   {
91512     try {
91513       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
91514     } catch (std::out_of_range& e) {
91515       {
91516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91517       };
91518     } catch (std::exception& e) {
91519       {
91520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91521       };
91522     } catch (...) {
91523       {
91524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91525       };
91526     }
91527   }
91528 }
91529
91530
91531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
91532   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91533   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
91534
91535   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91536   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
91537   {
91538     try {
91539       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
91540     } catch (std::out_of_range& e) {
91541       {
91542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91543       };
91544     } catch (std::exception& e) {
91545       {
91546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91547       };
91548     } catch (...) {
91549       {
91550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91551       };
91552     }
91553   }
91554 }
91555
91556
91557 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
91558   unsigned int jresult ;
91559   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91560   Dali::Toolkit::Slider arg2 ;
91561   float arg3 ;
91562   Dali::Toolkit::Slider *argp2 ;
91563   bool result;
91564
91565   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91566   argp2 = (Dali::Toolkit::Slider *)jarg2;
91567   if (!argp2) {
91568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
91569     return 0;
91570   }
91571   arg2 = *argp2;
91572   arg3 = (float)jarg3;
91573   {
91574     try {
91575       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
91576     } catch (std::out_of_range& e) {
91577       {
91578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91579       };
91580     } catch (std::exception& e) {
91581       {
91582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91583       };
91584     } catch (...) {
91585       {
91586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91587       };
91588     }
91589   }
91590   jresult = result;
91591   return jresult;
91592 }
91593
91594
91595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
91596   void * jresult ;
91597   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
91598
91599   {
91600     try {
91601       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
91602     } catch (std::out_of_range& e) {
91603       {
91604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91605       };
91606     } catch (std::exception& e) {
91607       {
91608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91609       };
91610     } catch (...) {
91611       {
91612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91613       };
91614     }
91615   }
91616   jresult = (void *)result;
91617   return jresult;
91618 }
91619
91620
91621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
91622   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91623
91624   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91625   {
91626     try {
91627       delete arg1;
91628     } catch (std::out_of_range& e) {
91629       {
91630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91631       };
91632     } catch (std::exception& e) {
91633       {
91634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91635       };
91636     } catch (...) {
91637       {
91638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91639       };
91640     }
91641   }
91642 }
91643
91644
91645 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
91646   unsigned int jresult ;
91647   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91648   bool result;
91649
91650   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91651   {
91652     try {
91653       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
91654     } catch (std::out_of_range& e) {
91655       {
91656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91657       };
91658     } catch (std::exception& e) {
91659       {
91660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91661       };
91662     } catch (...) {
91663       {
91664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91665       };
91666     }
91667   }
91668   jresult = result;
91669   return jresult;
91670 }
91671
91672
91673 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
91674   unsigned long jresult ;
91675   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91676   std::size_t result;
91677
91678   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91679   {
91680     try {
91681       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
91682     } catch (std::out_of_range& e) {
91683       {
91684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91685       };
91686     } catch (std::exception& e) {
91687       {
91688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91689       };
91690     } catch (...) {
91691       {
91692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91693       };
91694     }
91695   }
91696   jresult = (unsigned long)result;
91697   return jresult;
91698 }
91699
91700
91701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
91702   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91703   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
91704
91705   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91706   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
91707   {
91708     try {
91709       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
91710     } catch (std::out_of_range& e) {
91711       {
91712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91713       };
91714     } catch (std::exception& e) {
91715       {
91716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91717       };
91718     } catch (...) {
91719       {
91720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91721       };
91722     }
91723   }
91724 }
91725
91726
91727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
91728   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91729   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
91730
91731   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91732   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
91733   {
91734     try {
91735       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
91736     } catch (std::out_of_range& e) {
91737       {
91738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91739       };
91740     } catch (std::exception& e) {
91741       {
91742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91743       };
91744     } catch (...) {
91745       {
91746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91747       };
91748     }
91749   }
91750 }
91751
91752
91753 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
91754   unsigned int jresult ;
91755   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91756   Dali::Toolkit::Slider arg2 ;
91757   int arg3 ;
91758   Dali::Toolkit::Slider *argp2 ;
91759   bool result;
91760
91761   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91762   argp2 = (Dali::Toolkit::Slider *)jarg2;
91763   if (!argp2) {
91764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
91765     return 0;
91766   }
91767   arg2 = *argp2;
91768   arg3 = (int)jarg3;
91769   {
91770     try {
91771       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
91772     } catch (std::out_of_range& e) {
91773       {
91774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91775       };
91776     } catch (std::exception& e) {
91777       {
91778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91779       };
91780     } catch (...) {
91781       {
91782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91783       };
91784     }
91785   }
91786   jresult = result;
91787   return jresult;
91788 }
91789
91790
91791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
91792   void * jresult ;
91793   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
91794
91795   {
91796     try {
91797       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
91798     } catch (std::out_of_range& e) {
91799       {
91800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91801       };
91802     } catch (std::exception& e) {
91803       {
91804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91805       };
91806     } catch (...) {
91807       {
91808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91809       };
91810     }
91811   }
91812   jresult = (void *)result;
91813   return jresult;
91814 }
91815
91816
91817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
91818   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91819
91820   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91821   {
91822     try {
91823       delete arg1;
91824     } catch (std::out_of_range& e) {
91825       {
91826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91827       };
91828     } catch (std::exception& e) {
91829       {
91830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91831       };
91832     } catch (...) {
91833       {
91834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91835       };
91836     }
91837   }
91838 }
91839
91840
91841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
91842   void * jresult ;
91843   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91844
91845   {
91846     try {
91847       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
91848     } catch (std::out_of_range& e) {
91849       {
91850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91851       };
91852     } catch (std::exception& e) {
91853       {
91854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91855       };
91856     } catch (...) {
91857       {
91858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91859       };
91860     }
91861   }
91862   jresult = (void *)result;
91863   return jresult;
91864 }
91865
91866
91867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
91868   void * jresult ;
91869   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
91870   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91871
91872   arg1 = (Dali::Toolkit::Ruler *)jarg1;
91873   {
91874     try {
91875       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
91876     } catch (std::out_of_range& e) {
91877       {
91878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91879       };
91880     } catch (std::exception& e) {
91881       {
91882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91883       };
91884     } catch (...) {
91885       {
91886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91887       };
91888     }
91889   }
91890   jresult = (void *)result;
91891   return jresult;
91892 }
91893
91894
91895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
91896   void * jresult ;
91897   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
91898   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91899
91900   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91901   if (!arg1) {
91902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
91903     return 0;
91904   }
91905   {
91906     try {
91907       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
91908     } catch (std::out_of_range& e) {
91909       {
91910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91911       };
91912     } catch (std::exception& e) {
91913       {
91914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91915       };
91916     } catch (...) {
91917       {
91918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91919       };
91920     }
91921   }
91922   jresult = (void *)result;
91923   return jresult;
91924 }
91925
91926
91927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
91928   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91929
91930   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91931   {
91932     try {
91933       delete arg1;
91934     } catch (std::out_of_range& e) {
91935       {
91936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91937       };
91938     } catch (std::exception& e) {
91939       {
91940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91941       };
91942     } catch (...) {
91943       {
91944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91945       };
91946     }
91947   }
91948 }
91949
91950
91951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
91952   void * jresult ;
91953   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91954   Dali::Toolkit::Ruler *result = 0 ;
91955
91956   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91957   {
91958     try {
91959       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
91960     } catch (std::out_of_range& e) {
91961       {
91962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91963       };
91964     } catch (std::exception& e) {
91965       {
91966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91967       };
91968     } catch (...) {
91969       {
91970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91971       };
91972     }
91973   }
91974   jresult = (void *)result;
91975   return jresult;
91976 }
91977
91978
91979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
91980   void * jresult ;
91981   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91982   Dali::Toolkit::Ruler *result = 0 ;
91983
91984   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91985   {
91986     try {
91987       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
91988     } catch (std::out_of_range& e) {
91989       {
91990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91991       };
91992     } catch (std::exception& e) {
91993       {
91994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91995       };
91996     } catch (...) {
91997       {
91998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91999       };
92000     }
92001   }
92002   jresult = (void *)result;
92003   return jresult;
92004 }
92005
92006
92007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
92008   void * jresult ;
92009   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92010   Dali::Toolkit::Ruler *result = 0 ;
92011
92012   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92013   {
92014     try {
92015       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
92016     } catch (std::out_of_range& e) {
92017       {
92018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92019       };
92020     } catch (std::exception& e) {
92021       {
92022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92023       };
92024     } catch (...) {
92025       {
92026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92027       };
92028     }
92029   }
92030   jresult = (void *)result;
92031   return jresult;
92032 }
92033
92034
92035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
92036   void * jresult ;
92037   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92038   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
92039   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92040
92041   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92042   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
92043   if (!arg2) {
92044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
92045     return 0;
92046   }
92047   {
92048     try {
92049       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
92050     } catch (std::out_of_range& e) {
92051       {
92052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92053       };
92054     } catch (std::exception& e) {
92055       {
92056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92057       };
92058     } catch (...) {
92059       {
92060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92061       };
92062     }
92063   }
92064   jresult = (void *)result;
92065   return jresult;
92066 }
92067
92068
92069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
92070   void * jresult ;
92071   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92072   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
92073   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92074
92075   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92076   arg2 = (Dali::Toolkit::Ruler *)jarg2;
92077   {
92078     try {
92079       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
92080     } catch (std::out_of_range& e) {
92081       {
92082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92083       };
92084     } catch (std::exception& e) {
92085       {
92086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92087       };
92088     } catch (...) {
92089       {
92090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92091       };
92092     }
92093   }
92094   jresult = (void *)result;
92095   return jresult;
92096 }
92097
92098
92099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
92100   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92101
92102   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92103   {
92104     try {
92105       (arg1)->Reset();
92106     } catch (std::out_of_range& e) {
92107       {
92108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92109       };
92110     } catch (std::exception& e) {
92111       {
92112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92113       };
92114     } catch (...) {
92115       {
92116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92117       };
92118     }
92119   }
92120 }
92121
92122
92123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
92124   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92125   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
92126
92127   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92128   arg2 = (Dali::Toolkit::Ruler *)jarg2;
92129   {
92130     try {
92131       (arg1)->Reset(arg2);
92132     } catch (std::out_of_range& e) {
92133       {
92134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92135       };
92136     } catch (std::exception& e) {
92137       {
92138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92139       };
92140     } catch (...) {
92141       {
92142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92143       };
92144     }
92145   }
92146 }
92147
92148
92149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
92150   void * jresult ;
92151   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92152   Dali::Toolkit::Ruler *result = 0 ;
92153
92154   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92155   {
92156     try {
92157       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
92158     } catch (std::out_of_range& e) {
92159       {
92160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92161       };
92162     } catch (std::exception& e) {
92163       {
92164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92165       };
92166     } catch (...) {
92167       {
92168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92169       };
92170     }
92171   }
92172   jresult = (void *)result;
92173   return jresult;
92174 }
92175
92176
92177 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
92178   float jresult ;
92179   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92180   float arg2 ;
92181   float arg3 ;
92182   float result;
92183
92184   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92185   arg2 = (float)jarg2;
92186   arg3 = (float)jarg3;
92187   {
92188     try {
92189       result = (float)(*arg1)->Snap(arg2,arg3);
92190     } catch (std::out_of_range& e) {
92191       {
92192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92193       };
92194     } catch (std::exception& e) {
92195       {
92196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92197       };
92198     } catch (...) {
92199       {
92200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92201       };
92202     }
92203   }
92204   jresult = result;
92205   return jresult;
92206 }
92207
92208
92209 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
92210   float jresult ;
92211   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92212   float arg2 ;
92213   float result;
92214
92215   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92216   arg2 = (float)jarg2;
92217   {
92218     try {
92219       result = (float)(*arg1)->Snap(arg2);
92220     } catch (std::out_of_range& e) {
92221       {
92222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92223       };
92224     } catch (std::exception& e) {
92225       {
92226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92227       };
92228     } catch (...) {
92229       {
92230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92231       };
92232     }
92233   }
92234   jresult = result;
92235   return jresult;
92236 }
92237
92238
92239 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
92240   float jresult ;
92241   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92242   unsigned int arg2 ;
92243   unsigned int *arg3 = 0 ;
92244   bool arg4 ;
92245   float result;
92246
92247   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92248   arg2 = (unsigned int)jarg2;
92249   arg3 = (unsigned int *)jarg3;
92250   arg4 = jarg4 ? true : false;
92251   {
92252     try {
92253       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
92254     } catch (std::out_of_range& e) {
92255       {
92256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92257       };
92258     } catch (std::exception& e) {
92259       {
92260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92261       };
92262     } catch (...) {
92263       {
92264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92265       };
92266     }
92267   }
92268   jresult = result;
92269   return jresult;
92270 }
92271
92272
92273 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
92274   unsigned int jresult ;
92275   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92276   float arg2 ;
92277   bool arg3 ;
92278   unsigned int result;
92279
92280   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92281   arg2 = (float)jarg2;
92282   arg3 = jarg3 ? true : false;
92283   {
92284     try {
92285       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
92286     } catch (std::out_of_range& e) {
92287       {
92288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92289       };
92290     } catch (std::exception& e) {
92291       {
92292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92293       };
92294     } catch (...) {
92295       {
92296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92297       };
92298     }
92299   }
92300   jresult = result;
92301   return jresult;
92302 }
92303
92304
92305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
92306   unsigned int jresult ;
92307   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92308   unsigned int result;
92309
92310   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92311   {
92312     try {
92313       result = (unsigned int)(*arg1)->GetTotalPages();
92314     } catch (std::out_of_range& e) {
92315       {
92316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92317       };
92318     } catch (std::exception& e) {
92319       {
92320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92321       };
92322     } catch (...) {
92323       {
92324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92325       };
92326     }
92327   }
92328   jresult = result;
92329   return jresult;
92330 }
92331
92332
92333 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
92334   int jresult ;
92335   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92336   Dali::Toolkit::Ruler::RulerType result;
92337
92338   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92339   {
92340     try {
92341       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
92342     } catch (std::out_of_range& e) {
92343       {
92344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92345       };
92346     } catch (std::exception& e) {
92347       {
92348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92349       };
92350     } catch (...) {
92351       {
92352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92353       };
92354     }
92355   }
92356   jresult = (int)result;
92357   return jresult;
92358 }
92359
92360
92361 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
92362   unsigned int jresult ;
92363   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92364   bool result;
92365
92366   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92367   {
92368     try {
92369       result = (bool)(*arg1)->IsEnabled();
92370     } catch (std::out_of_range& e) {
92371       {
92372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92373       };
92374     } catch (std::exception& e) {
92375       {
92376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92377       };
92378     } catch (...) {
92379       {
92380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92381       };
92382     }
92383   }
92384   jresult = result;
92385   return jresult;
92386 }
92387
92388
92389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
92390   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92391
92392   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92393   {
92394     try {
92395       (*arg1)->Enable();
92396     } catch (std::out_of_range& e) {
92397       {
92398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92399       };
92400     } catch (std::exception& e) {
92401       {
92402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92403       };
92404     } catch (...) {
92405       {
92406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92407       };
92408     }
92409   }
92410 }
92411
92412
92413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
92414   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92415
92416   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92417   {
92418     try {
92419       (*arg1)->Disable();
92420     } catch (std::out_of_range& e) {
92421       {
92422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92423       };
92424     } catch (std::exception& e) {
92425       {
92426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92427       };
92428     } catch (...) {
92429       {
92430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92431       };
92432     }
92433   }
92434 }
92435
92436
92437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
92438   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92439   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
92440   Dali::Toolkit::RulerDomain *argp2 ;
92441
92442   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92443   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
92444   if (!argp2) {
92445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
92446     return ;
92447   }
92448   arg2 = *argp2;
92449   {
92450     try {
92451       (*arg1)->SetDomain(arg2);
92452     } catch (std::out_of_range& e) {
92453       {
92454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92455       };
92456     } catch (std::exception& e) {
92457       {
92458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92459       };
92460     } catch (...) {
92461       {
92462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92463       };
92464     }
92465   }
92466 }
92467
92468
92469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
92470   void * jresult ;
92471   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92472   Dali::Toolkit::RulerDomain *result = 0 ;
92473
92474   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92475   {
92476     try {
92477       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
92478     } catch (std::out_of_range& e) {
92479       {
92480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92481       };
92482     } catch (std::exception& e) {
92483       {
92484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92485       };
92486     } catch (...) {
92487       {
92488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92489       };
92490     }
92491   }
92492   jresult = (void *)result;
92493   return jresult;
92494 }
92495
92496
92497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
92498   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92499
92500   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92501   {
92502     try {
92503       (*arg1)->DisableDomain();
92504     } catch (std::out_of_range& e) {
92505       {
92506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92507       };
92508     } catch (std::exception& e) {
92509       {
92510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92511       };
92512     } catch (...) {
92513       {
92514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92515       };
92516     }
92517   }
92518 }
92519
92520
92521 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
92522   float jresult ;
92523   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92524   float arg2 ;
92525   float arg3 ;
92526   float arg4 ;
92527   float result;
92528
92529   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92530   arg2 = (float)jarg2;
92531   arg3 = (float)jarg3;
92532   arg4 = (float)jarg4;
92533   {
92534     try {
92535       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
92536     } catch (std::out_of_range& e) {
92537       {
92538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92539       };
92540     } catch (std::exception& e) {
92541       {
92542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92543       };
92544     } catch (...) {
92545       {
92546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92547       };
92548     }
92549   }
92550   jresult = result;
92551   return jresult;
92552 }
92553
92554
92555 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
92556   float jresult ;
92557   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92558   float arg2 ;
92559   float arg3 ;
92560   float result;
92561
92562   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92563   arg2 = (float)jarg2;
92564   arg3 = (float)jarg3;
92565   {
92566     try {
92567       result = (float)(*arg1)->Clamp(arg2,arg3);
92568     } catch (std::out_of_range& e) {
92569       {
92570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92571       };
92572     } catch (std::exception& e) {
92573       {
92574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92575       };
92576     } catch (...) {
92577       {
92578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92579       };
92580     }
92581   }
92582   jresult = result;
92583   return jresult;
92584 }
92585
92586
92587 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
92588   float jresult ;
92589   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92590   float arg2 ;
92591   float result;
92592
92593   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92594   arg2 = (float)jarg2;
92595   {
92596     try {
92597       result = (float)(*arg1)->Clamp(arg2);
92598     } catch (std::out_of_range& e) {
92599       {
92600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92601       };
92602     } catch (std::exception& e) {
92603       {
92604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92605       };
92606     } catch (...) {
92607       {
92608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92609       };
92610     }
92611   }
92612   jresult = result;
92613   return jresult;
92614 }
92615
92616
92617 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
92618   float jresult ;
92619   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92620   float arg2 ;
92621   float arg3 ;
92622   float arg4 ;
92623   Dali::Toolkit::ClampState *arg5 = 0 ;
92624   float result;
92625
92626   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92627   arg2 = (float)jarg2;
92628   arg3 = (float)jarg3;
92629   arg4 = (float)jarg4;
92630   arg5 = (Dali::Toolkit::ClampState *)jarg5;
92631   if (!arg5) {
92632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
92633     return 0;
92634   }
92635   {
92636     try {
92637       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
92638     } catch (std::out_of_range& e) {
92639       {
92640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92641       };
92642     } catch (std::exception& e) {
92643       {
92644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92645       };
92646     } catch (...) {
92647       {
92648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92649       };
92650     }
92651   }
92652   jresult = result;
92653   return jresult;
92654 }
92655
92656
92657 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
92658   float jresult ;
92659   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92660   float arg2 ;
92661   float arg3 ;
92662   float arg4 ;
92663   float arg5 ;
92664   float result;
92665
92666   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92667   arg2 = (float)jarg2;
92668   arg3 = (float)jarg3;
92669   arg4 = (float)jarg4;
92670   arg5 = (float)jarg5;
92671   {
92672     try {
92673       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
92674     } catch (std::out_of_range& e) {
92675       {
92676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92677       };
92678     } catch (std::exception& e) {
92679       {
92680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92681       };
92682     } catch (...) {
92683       {
92684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92685       };
92686     }
92687   }
92688   jresult = result;
92689   return jresult;
92690 }
92691
92692
92693 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
92694   float jresult ;
92695   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92696   float arg2 ;
92697   float arg3 ;
92698   float arg4 ;
92699   float result;
92700
92701   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92702   arg2 = (float)jarg2;
92703   arg3 = (float)jarg3;
92704   arg4 = (float)jarg4;
92705   {
92706     try {
92707       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
92708     } catch (std::out_of_range& e) {
92709       {
92710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92711       };
92712     } catch (std::exception& e) {
92713       {
92714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92715       };
92716     } catch (...) {
92717       {
92718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92719       };
92720     }
92721   }
92722   jresult = result;
92723   return jresult;
92724 }
92725
92726
92727 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
92728   float jresult ;
92729   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92730   float arg2 ;
92731   float arg3 ;
92732   float result;
92733
92734   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92735   arg2 = (float)jarg2;
92736   arg3 = (float)jarg3;
92737   {
92738     try {
92739       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
92740     } catch (std::out_of_range& e) {
92741       {
92742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92743       };
92744     } catch (std::exception& e) {
92745       {
92746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92747       };
92748     } catch (...) {
92749       {
92750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92751       };
92752     }
92753   }
92754   jresult = result;
92755   return jresult;
92756 }
92757
92758
92759 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
92760   float jresult ;
92761   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92762   float arg2 ;
92763   float result;
92764
92765   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92766   arg2 = (float)jarg2;
92767   {
92768     try {
92769       result = (float)(*arg1)->SnapAndClamp(arg2);
92770     } catch (std::out_of_range& e) {
92771       {
92772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92773       };
92774     } catch (std::exception& e) {
92775       {
92776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92777       };
92778     } catch (...) {
92779       {
92780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92781       };
92782     }
92783   }
92784   jresult = result;
92785   return jresult;
92786 }
92787
92788
92789 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
92790   float jresult ;
92791   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92792   float arg2 ;
92793   float arg3 ;
92794   float arg4 ;
92795   float arg5 ;
92796   Dali::Toolkit::ClampState *arg6 = 0 ;
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   arg6 = (Dali::Toolkit::ClampState *)jarg6;
92805   if (!arg6) {
92806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
92807     return 0;
92808   }
92809   {
92810     try {
92811       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
92812     } catch (std::out_of_range& e) {
92813       {
92814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92815       };
92816     } catch (std::exception& e) {
92817       {
92818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92819       };
92820     } catch (...) {
92821       {
92822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92823       };
92824     }
92825   }
92826   jresult = result;
92827   return jresult;
92828 }
92829
92830
92831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
92832   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92833
92834   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92835   {
92836     try {
92837       (*arg1)->Reference();
92838     } catch (std::out_of_range& e) {
92839       {
92840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92841       };
92842     } catch (std::exception& e) {
92843       {
92844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92845       };
92846     } catch (...) {
92847       {
92848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92849       };
92850     }
92851   }
92852 }
92853
92854
92855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
92856   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92857
92858   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92859   {
92860     try {
92861       (*arg1)->Unreference();
92862     } catch (std::out_of_range& e) {
92863       {
92864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92865       };
92866     } catch (std::exception& e) {
92867       {
92868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92869       };
92870     } catch (...) {
92871       {
92872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92873       };
92874     }
92875   }
92876 }
92877
92878
92879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
92880   int jresult ;
92881   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92882   int result;
92883
92884   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92885   {
92886     try {
92887       result = (int)(*arg1)->ReferenceCount();
92888     } catch (std::out_of_range& e) {
92889       {
92890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92891       };
92892     } catch (std::exception& e) {
92893       {
92894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92895       };
92896     } catch (...) {
92897       {
92898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92899       };
92900     }
92901   }
92902   jresult = result;
92903   return jresult;
92904 }
92905
92906
92907 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
92908     return (Dali::RefObject *)jarg1;
92909 }
92910
92911 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
92912     return (Dali::SignalObserver *)jarg1;
92913 }
92914
92915 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
92916     return (Dali::ConnectionTrackerInterface *)jarg1;
92917 }
92918
92919 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
92920     return (Dali::BaseHandle *)jarg1;
92921 }
92922
92923 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
92924     return (Dali::BaseHandle *)jarg1;
92925 }
92926
92927 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
92928     return (Dali::BaseHandle *)jarg1;
92929 }
92930
92931 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
92932     return (Dali::BaseHandle *)jarg1;
92933 }
92934
92935 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
92936     return (Dali::BaseHandle *)jarg1;
92937 }
92938
92939 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
92940     return (Dali::BaseHandle *)jarg1;
92941 }
92942
92943 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
92944     return (Dali::BaseHandle *)jarg1;
92945 }
92946
92947 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
92948     return (Dali::BaseHandle *)jarg1;
92949 }
92950
92951 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
92952     return (Dali::BaseHandle *)jarg1;
92953 }
92954
92955 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
92956     return (Dali::BaseHandle *)jarg1;
92957 }
92958
92959 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
92960     return (Dali::BaseHandle *)jarg1;
92961 }
92962
92963 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
92964     return (Dali::BaseHandle *)jarg1;
92965 }
92966
92967 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
92968     return (Dali::BaseHandle *)jarg1;
92969 }
92970
92971 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
92972     return (Dali::Handle *)jarg1;
92973 }
92974
92975 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
92976     return (Dali::Handle *)jarg1;
92977 }
92978
92979 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
92980     return (Dali::BaseHandle *)jarg1;
92981 }
92982
92983 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
92984     return (Dali::BaseHandle *)jarg1;
92985 }
92986
92987 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
92988     return (Dali::Handle *)jarg1;
92989 }
92990
92991 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
92992     return (Dali::BaseHandle *)jarg1;
92993 }
92994
92995 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
92996     return (Dali::Handle *)jarg1;
92997 }
92998
92999 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
93000     return (Dali::GestureDetector *)jarg1;
93001 }
93002
93003 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
93004     return (Dali::Gesture *)jarg1;
93005 }
93006
93007 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
93008     return (Dali::Handle *)jarg1;
93009 }
93010
93011 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
93012     return (Dali::Actor *)jarg1;
93013 }
93014
93015 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
93016     return (Dali::BaseHandle *)jarg1;
93017 }
93018
93019 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
93020     return (Dali::RefObject *)jarg1;
93021 }
93022
93023 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
93024     return (Dali::Actor *)jarg1;
93025 }
93026
93027 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
93028     return (Dali::GestureDetector *)jarg1;
93029 }
93030
93031 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
93032     return (Dali::Gesture *)jarg1;
93033 }
93034
93035 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
93036     return (Dali::GestureDetector *)jarg1;
93037 }
93038
93039 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
93040     return (Dali::Gesture *)jarg1;
93041 }
93042
93043 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
93044     return (Dali::GestureDetector *)jarg1;
93045 }
93046
93047 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
93048     return (Dali::Gesture *)jarg1;
93049 }
93050
93051 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
93052     return (Dali::BaseHandle *)jarg1;
93053 }
93054
93055 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
93056     return (Dali::Handle *)jarg1;
93057 }
93058
93059 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Animation_SWIGUpcast(Dali::Animation *jarg1) {
93060     return (Dali::BaseHandle *)jarg1;
93061 }
93062
93063 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
93064     return (Dali::Handle *)jarg1;
93065 }
93066
93067 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
93068     return (Dali::Handle *)jarg1;
93069 }
93070
93071 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
93072     return (Dali::Image *)jarg1;
93073 }
93074
93075 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
93076     return (Dali::Image *)jarg1;
93077 }
93078
93079 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
93080     return (Dali::Image *)jarg1;
93081 }
93082
93083 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
93084     return (Dali::RefObject *)jarg1;
93085 }
93086
93087 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
93088     return (Dali::Image *)jarg1;
93089 }
93090
93091 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
93092     return (Dali::Image *)jarg1;
93093 }
93094
93095 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
93096     return (Dali::ResourceImage *)jarg1;
93097 }
93098
93099 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
93100     return (Dali::Actor *)jarg1;
93101 }
93102
93103 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
93104     return (Dali::BaseHandle *)jarg1;
93105 }
93106
93107 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
93108     return (Dali::BaseHandle *)jarg1;
93109 }
93110
93111 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Window_SWIGUpcast(Dali::Window *jarg1) {
93112     return (Dali::BaseHandle *)jarg1;
93113 }
93114
93115 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Application_SWIGUpcast(Dali::Application *jarg1) {
93116     return (Dali::BaseHandle *)jarg1;
93117 }
93118
93119 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
93120     return (Dali::BaseHandle *)jarg1;
93121 }
93122
93123 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
93124     return (Dali::BaseHandle *)jarg1;
93125 }
93126
93127 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
93128     return (Dali::CustomActorImpl *)jarg1;
93129 }
93130
93131 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
93132     return (Dali::CustomActor *)jarg1;
93133 }
93134
93135 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
93136     return (Dali::BaseHandle *)jarg1;
93137 }
93138
93139 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
93140     return (Dali::Toolkit::Control *)jarg1;
93141 }
93142
93143 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
93144     return (Dali::Toolkit::Control *)jarg1;
93145 }
93146
93147 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
93148     return (Dali::Toolkit::Button *)jarg1;
93149 }
93150
93151 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
93152     return (Dali::Toolkit::Button *)jarg1;
93153 }
93154
93155 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
93156     return (Dali::Toolkit::Button *)jarg1;
93157 }
93158
93159 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
93160     return (Dali::Toolkit::Control *)jarg1;
93161 }
93162
93163 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
93164     return (Dali::Toolkit::Control *)jarg1;
93165 }
93166
93167 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
93168     return (Dali::Toolkit::Control *)jarg1;
93169 }
93170
93171 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
93172     return (Dali::Toolkit::Control *)jarg1;
93173 }
93174
93175 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
93176     return (Dali::Toolkit::Control *)jarg1;
93177 }
93178
93179 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
93180     return (Dali::RefObject *)jarg1;
93181 }
93182
93183 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
93184     return (Dali::Toolkit::Scrollable *)jarg1;
93185 }
93186
93187 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
93188     return (Dali::BaseHandle *)jarg1;
93189 }
93190
93191 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
93192     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
93193 }
93194
93195 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
93196     return (Dali::RefObject *)jarg1;
93197 }
93198
93199 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
93200     return (Dali::Toolkit::Ruler *)jarg1;
93201 }
93202
93203 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
93204     return (Dali::Toolkit::Ruler *)jarg1;
93205 }
93206
93207 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
93208     return (Dali::Toolkit::Scrollable *)jarg1;
93209 }
93210
93211 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
93212     return (Dali::Toolkit::Control *)jarg1;
93213 }
93214
93215 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextEditor_SWIGUpcast(Dali::Toolkit::TextEditor *jarg1) {
93216     return (Dali::Toolkit::Control *)jarg1;
93217 }
93218
93219 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextField_SWIGUpcast(Dali::Toolkit::TextField *jarg1) {
93220     return (Dali::Toolkit::Control *)jarg1;
93221 }
93222
93223 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
93224     return (Dali::Toolkit::Control *)jarg1;
93225 }
93226
93227 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
93228     return (Dali::BaseHandle *)jarg1;
93229 }
93230
93231 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
93232     return (Dali::BaseHandle *)jarg1;
93233 }
93234
93235 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
93236     return (Dali::Toolkit::Control *)jarg1;
93237 }
93238
93239 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
93240     return (Dali::Toolkit::Control *)jarg1;
93241 }
93242
93243 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
93244     return (Dali::Toolkit::Control *)jarg1;
93245 }
93246
93247 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
93248     return (Dali::Toolkit::Control *)jarg1;
93249 }
93250
93251 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
93252     return (Dali::Toolkit::Control *)jarg1;
93253 }
93254
93255 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
93256     return (Dali::Toolkit::Control *)jarg1;
93257 }
93258
93259 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
93260     return (Dali::Toolkit::PageTurnView *)jarg1;
93261 }
93262
93263 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
93264     return (Dali::Toolkit::PageTurnView *)jarg1;
93265 }
93266
93267 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
93268     return (Dali::Toolkit::Button *)jarg1;
93269 }
93270
93271 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
93272     return (Dali::BaseHandle *)jarg1;
93273 }
93274
93275 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
93276     return (Dali::BaseHandle *)jarg1;
93277 }
93278
93279 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
93280     return (Dali::BaseHandle *)jarg1;
93281 }
93282
93283 #ifdef __cplusplus
93284 }
93285 #endif
93286